{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第3章 线性分类\n",
    "\n",
    "分类是机器学习中最常见的一类任务，其预测标签是一些离散的类别（符号）。根据分类任务的类别数量又可以分为二分类任务和多分类任务。\n",
    "\n",
    "线性分类是指利用一个或多个线性函数将样本进行分类。常用的线性分类模型有Logistic回归和Softmax回归。\n",
    "Logistic回归是一种常用的处理二分类问题的线性模型。Softmax回归是Logistic回归在多分类问题上的推广。\n",
    "\n",
    "在学习本章内容前，建议您先阅读《神经网络与深度学习》第3章：线性模型的相关内容，关键知识点如 **图3.1** 所示，以便更好的理解和掌握相应的理论知识，及其在实践中的应用方法。\n",
    "\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/797cd285fbb14112944378971ddf402a7a7f3d8fdc41461ebd4373b3770a3b46\" width=400></center>\n",
    "<br><center>图3.1 线性模型关键知识点回顾</center></br>\n",
    "\n",
    "本章内容基于 **《神经网络与深度学习》第3章：线性模型** 相关内容进行设计，主要包含两部分：\n",
    "\n",
    "* **模型解读**：介绍两个最常用的线性分类模型Logistic回归和Softmax回归的原理剖析和相应的代码实现。通过理论和代码的结合，加深对线性模型的理解；\n",
    "\n",
    "* **案例实践**：基于Softmax回归算法完成鸢尾花分类任务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 3.1 基于Logistic回归的二分类任务\n",
    "\n",
    "在本节中，我们实现一个Logistic回归模型，并对一个简单的数据集进行二分类实验。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.1 数据集构建\n",
    "\n",
    "我们首先构建一个简单的分类任务，并构建训练集、验证集和测试集。\n",
    "本任务的数据来自带噪音的两个弯月形状函数，每个弯月对一个类别。我们采集1000条样本，每个样本包含2个特征。\n",
    "\n",
    "数据集的构建函数`make_moons`的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import copy\n",
    "import paddle\n",
    "\n",
    "def make_moons(n_samples=1000, shuffle=True, noise=None):\n",
    "    \"\"\"\n",
    "    生成带噪音的弯月形状数据\n",
    "    输入：\n",
    "        - n_samples：数据量大小，数据类型为int\n",
    "        - shuffle：是否打乱数据，数据类型为bool\n",
    "        - noise：以多大的程度增加噪声，数据类型为None或float，noise为None时表示不增加噪声\n",
    "    输出：\n",
    "        - X：特征数据，shape=[n_samples,2]\n",
    "        - y：标签数据, shape=[n_samples]\n",
    "    \"\"\"\n",
    "    n_samples_out = n_samples // 2\n",
    "    n_samples_in = n_samples - n_samples_out\n",
    "\n",
    "    # 采集第1类数据，特征为(x,y)\n",
    "    # 使用'paddle.linspace'在0到pi上均匀取n_samples_out个值\n",
    "    # 使用'paddle.cos'计算上述取值的余弦值作为特征1，使用'paddle.sin'计算上述取值的正弦值作为特征2\n",
    "    outer_circ_x = paddle.cos(paddle.linspace(0, math.pi, n_samples_out))\n",
    "    outer_circ_y = paddle.sin(paddle.linspace(0, math.pi, n_samples_out))\n",
    "\n",
    "    inner_circ_x = 1 - paddle.cos(paddle.linspace(0, math.pi, n_samples_in))\n",
    "    inner_circ_y = 0.5 - paddle.sin(paddle.linspace(0, math.pi, n_samples_in))\n",
    "    \n",
    "    print('outer_circ_x.shape:', outer_circ_x.shape, 'outer_circ_y.shape:', outer_circ_y.shape)\n",
    "    print('inner_circ_x.shape:', inner_circ_x.shape, 'inner_circ_y.shape:', inner_circ_y.shape)\n",
    "    \n",
    "    # 使用'paddle.concat'将两类数据的特征1和特征2分别延维度0拼接在一起，得到全部特征1和特征2\n",
    "    # 使用'paddle.stack'将两类特征延维度1堆叠在一起\n",
    "    X = paddle.stack(\n",
    "        [paddle.concat([outer_circ_x, inner_circ_x]),\n",
    "        paddle.concat([outer_circ_y, inner_circ_y])],\n",
    "        axis=1\n",
    "    )\n",
    "\n",
    "    print('after concat shape:', paddle.concat([outer_circ_x, inner_circ_x]).shape)\n",
    "    print('X shape:', X.shape)\n",
    "\n",
    "    # 使用'paddle. zeros'将第一类数据的标签全部设置为0\n",
    "    # 使用'paddle. ones'将第一类数据的标签全部设置为1\n",
    "    y = paddle.concat(\n",
    "        [paddle.zeros(shape=[n_samples_out]), paddle.ones(shape=[n_samples_in])]\n",
    "    )\n",
    "\n",
    "    print('y shape:', y.shape)\n",
    "\n",
    "    # 如果shuffle为True，将所有数据打乱\n",
    "    if shuffle:\n",
    "        # 使用'paddle.randperm'生成一个数值在0到X.shape[0]，随机排列的一维Tensor做索引值，用于打乱数据\n",
    "        idx = paddle.randperm(X.shape[0])\n",
    "        X = X[idx]\n",
    "        y = y[idx]\n",
    "\n",
    "    # 如果noise不为None，则给特征值加入噪声\n",
    "    if noise is not None:\n",
    "        # 使用'paddle.normal'生成符合正态分布的随机Tensor作为噪声，并加到原始特征上\n",
    "        X += paddle.normal(mean=0.0, std=noise, shape=X.shape)\n",
    "\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "随机采集1000个样本，并进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outer_circ_x.shape: [500] outer_circ_y.shape: [500]\n",
      "inner_circ_x.shape: [500] inner_circ_y.shape: [500]\n",
      "after concat shape: [1000]\n",
      "X shape: [1000, 2]\n",
      "y shape: [1000]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/__init__.py:107: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import MutableMapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/rcsetup.py:20: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Iterable, Mapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/colors.py:53: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Sized\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2349: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  if isinstance(obj, collections.Iterator):\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2366: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  return list(data) if isinstance(data, collections.MappingView) else data\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 采样1000个样本\n",
    "n_samples = 1000\n",
    "X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5)\n",
    "# 可视化生产的数据集，不同颜色代表不同类别\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(5,5))\n",
    "plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist())\n",
    "plt.xlim(-3,4)\n",
    "plt.ylim(-3,4)\n",
    "plt.savefig('linear-dataset-vis.pdf')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "将1000条样本数据拆分成训练集、验证集和测试集，其中训练集640条、验证集160条、测试集200条。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "num_train = 640\n",
    "num_dev = 160\n",
    "num_test = 200\n",
    "\n",
    "X_train, y_train = X[:num_train], y[:num_train]\n",
    "X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]\n",
    "X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]\n",
    "\n",
    "y_train = y_train.reshape([-1,1])\n",
    "y_dev = y_dev.reshape([-1,1])\n",
    "y_test = y_test.reshape([-1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "这样，我们就完成了Moon1000数据集的构建。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape:  [640, 2] y_train shape:  [640, 1]\n"
     ]
    }
   ],
   "source": [
    "# 打印X_train和y_train的维度\n",
    "print(\"X_train shape: \", X_train.shape, \"y_train shape: \", y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[5, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[1.],\n",
      "        [0.],\n",
      "        [1.],\n",
      "        [0.],\n",
      "        [1.]])\n"
     ]
    }
   ],
   "source": [
    "# 打印一下前5个数据的标签\n",
    "print (y_train[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.2 模型构建\n",
    "\n",
    "Logistic回归是一种常用的处理二分类问题的线性模型。与线性回归一样，Logistic回归也会将输入特征与权重做线性叠加。不同之处在于，Logistic回归引入了非线性函数$g:\\mathbb{R}^D \\rightarrow (0,1)$，预测类别标签的后验概率 $p(y=1|\\mathbf x)$ ，从而解决连续的线性函数不适合进行分类的问题。\n",
    "\n",
    "$$\n",
    "p(y=1|\\mathbf x) = \\sigma(\\mathbf w^ \\mathrm{ T } \\mathbf x+b),（3.1）\n",
    "$$\n",
    "\n",
    "其中判别函数$\\sigma(\\cdot)$为Logistic函数，也称为激活函数，作用是将线性函数$f(\\mathbf x;\\mathbf w,b)$的输出从实数区间“挤压”到（0,1）之间，用来表示概率。Logistic函数定义为：\n",
    "\n",
    "$$\n",
    "\\sigma(x) = \\frac{1}{1+\\exp(-x)}。（3.2）\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Logistic函数**\n",
    "\n",
    "Logistic函数的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义Logistic函数\n",
    "def logistic(x):\n",
    "    return 1 / (1 + paddle.exp(-x))\n",
    "\n",
    "# 在[-10,10]的范围内生成一系列的输入值，用于绘制函数曲线\n",
    "x = paddle.linspace(-10, 10, 10000)\n",
    "plt.figure()\n",
    "plt.plot(x.tolist(), logistic(x).tolist(), color=\"#e4007f\", label=\"Logistic Function\")\n",
    "# 设置坐标轴\n",
    "ax = plt.gca()\n",
    "# 取消右侧和上侧坐标轴\n",
    "ax.spines['top'].set_color('none')\n",
    "ax.spines['right'].set_color('none')\n",
    "# 设置默认的x轴和y轴方向\n",
    "ax.xaxis.set_ticks_position('bottom') \n",
    "ax.yaxis.set_ticks_position('left')\n",
    "# 设置坐标原点为(0,0)\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "# 添加图例\n",
    "plt.legend()\n",
    "plt.savefig('linear-logistic.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从输出结果看，当输入在0附近时，Logistic函数近似为线性函数；而当输入值非常大或非常小时，函数会对输入进行抑制。输入越小，则越接近0；输入越大，则越接近1。正因为Logistic函数具有这样的性质，使得其输出可以直接看作为概率分布。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Logistic回归算子**\n",
    "\n",
    "Logistic回归模型其实就是线性层与Logistic函数的组合，通常会将 Logistic回归模型中的权重和偏置初始化为0，同时，为了提高预测样本的效率，我们将$N$个样本归为一组进行成批地预测。\n",
    "\n",
    "$$\n",
    "\\hat{\\mathbf y} = p(\\mathbf y|\\mathbf x) = \\sigma(\\boldsymbol{X} \\boldsymbol{w} + b), (3.3)\n",
    "$$\n",
    "\n",
    "其中$\\boldsymbol{X}\\in \\mathbb{R}^{N\\times D}$为$N$个样本的特征矩阵，$\\hat{\\boldsymbol{y}}$为$N$个样本的预测值构成的$N$维向量。\n",
    "\n",
    "这里，我们构建一个Logistic回归算子，代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from nndl import op\n",
    "\n",
    "class model_LR(op.Op):\n",
    "    def __init__(self, input_dim):\n",
    "        super(model_LR, self).__init__()\n",
    "        self.params = {}\n",
    "        # 将线性层的权重参数全部初始化为0\n",
    "        self.params['w'] = paddle.zeros(shape=[input_dim, 1])\n",
    "        # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])\n",
    "        # 将线性层的偏置参数初始化为0\n",
    "        self.params['b'] = paddle.zeros(shape=[1])\n",
    "\n",
    "    def __call__(self, inputs):\n",
    "        return self.forward(inputs)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - inputs: shape=[N,D], N是样本数量，D为特征维度\n",
    "        输出：\n",
    "            - outputs：预测标签为1的概率，shape=[N,1]\n",
    "        \"\"\"\n",
    "        # 线性计算\n",
    "        score = paddle.matmul(inputs, self.params['w']) + self.params['b']\n",
    "        # Logistic 函数\n",
    "        outputs = logistic(score)\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**测试一下**\n",
    "\n",
    "随机生成3条长度为4的数据输入Logistic回归模型，观察输出结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input is: Tensor(shape=[3, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[-4.08041382, -1.37199533,  0.25684971,  1.23514259],\n",
      "        [ 1.85156298, -0.87903994,  0.03754762, -0.25850555],\n",
      "        [-0.63441145,  0.65421218, -1.34354496,  0.15195791]])\n",
      "Output is: Tensor(shape=[3, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[0.50000000],\n",
      "        [0.50000000],\n",
      "        [0.50000000]])\n"
     ]
    }
   ],
   "source": [
    "# 固定随机种子，保持每次运行结果一致\n",
    "paddle.seed(0)\n",
    "# 随机生成3条长度为4的数据\n",
    "inputs = paddle.randn(shape=[3,4])\n",
    "print('Input is:', inputs)\n",
    "# 实例化模型\n",
    "model = model_LR(4)\n",
    "outputs = model(inputs)\n",
    "print('Output is:', outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从输出结果看，模型最终的输出$g(·)$恒为0.5。这是由于采用全0初始化后，不论输入值的大小为多少，Logistic函数的输入值恒为0，因此输出恒为0.5。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.3 损失函数\n",
    "\n",
    "在模型训练过程中，需要使用损失函数来量化预测值和真实值之间的差异。\n",
    "给定一个分类任务，$\\mathbf y$表示样本$\\mathbf x$的标签的真实概率分布，向量$\\hat{\\mathbf y}=p(\\mathbf y|\\mathbf x)$表示预测的标签概率分布。\n",
    "训练目标是使得$\\hat{\\mathbf y}$尽可能地接近$\\mathbf y$，通常可以使用**交叉熵损失函数**。\n",
    "在给定$\\mathbf y$的情况下，如果预测的概率分布$\\hat{\\mathbf y}$与标签真实的分布$\\mathbf y$越接近，则交叉熵越小；如果$p(\\mathbf x)$和$\\mathbf y$越远，交叉熵就越大。\n",
    "\n",
    "对于二分类任务，我们只需要计算$\\hat{y}=p(y=1|\\mathbf x)$，用$1-\\hat{y}$来表示$p(y=0|\\mathbf x)$。\n",
    "给定有$N$个训练样本的训练集$\\{(\\mathbf x^{(n)},y^{(n)})\\} ^N_{n=1}$，使用交叉熵损失函数，Logistic回归的风险函数计算方式为：\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\cal R(\\mathbf w,b) &= -\\frac{1}{N}\\sum_{n=1}^N \\Big(y^{(n)}\\log\\hat{y}^{(n)} + (1-y^{(n)})\\log(1-\\hat{y}^{(n)})\\Big)。（3.4）\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "向量形式可以表示为：\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\cal R(\\mathbf w,b) &= -\\frac{1}{N}\\Big(\\mathbf y^ \\mathrm{ T }  \\log\\hat{\\mathbf y} + (1-\\mathbf y)^ \\mathrm{ T } \\log(1-\\hat{\\mathbf y})\\Big),（3.5）\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "其中$\\mathbf y\\in [0,1]^N$为$N$个样本的真实标签构成的$N$维向量，$\\hat{\\mathbf y}$为$N$个样本标签为1的后验概率构成的$N$维向量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "二分类任务的交叉熵损失函数的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [0.69335938])\n"
     ]
    }
   ],
   "source": [
    "# 实现交叉熵损失函数\n",
    "class BinaryCrossEntropyLoss(op.Op):\n",
    "    def __init__(self):\n",
    "        self.predicts = None\n",
    "        self.labels = None\n",
    "        self.num = None\n",
    "\n",
    "    def __call__(self, predicts, labels):\n",
    "        return self.forward(predicts, labels)\n",
    "\n",
    "    def forward(self, predicts, labels):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - predicts：预测值，shape=[N, 1]，N为样本数量\n",
    "            - labels：真实标签，shape=[N, 1]\n",
    "        输出：\n",
    "            - 损失值：shape=[1]\n",
    "        \"\"\"\n",
    "        self.predicts = predicts\n",
    "        self.labels = labels\n",
    "        self.num = self.predicts.shape[0]\n",
    "        loss = -1. / self.num * (paddle.matmul(self.labels.t(), paddle.log(self.predicts)) + paddle.matmul((1-self.labels.t()), paddle.log(1-self.predicts)))\n",
    "        loss = paddle.squeeze(loss, axis=1)\n",
    "        return loss\n",
    "\n",
    "# 测试一下\n",
    "# 生成一组长度为3，值为1的标签数据\n",
    "labels = paddle.ones(shape=[3,1])\n",
    "# 计算风险函数\n",
    "bce_loss = BinaryCrossEntropyLoss()\n",
    "print(bce_loss(outputs, labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.4 模型优化\n",
    "\n",
    "不同于线性回归中直接使用最小二乘法即可进行模型参数的求解，Logistic回归需要使用优化算法对模型参数进行有限次地迭代来获取更优的模型，从而尽可能地降低风险函数的值。\n",
    "在机器学习任务中，最简单、常用的优化算法是梯度下降法。\n",
    "\n",
    "使用梯度下降法进行模型优化，首先需要初始化参数$\\mathbf W$和 $b$，然后不断地计算它们的梯度，并沿梯度的反方向更新参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 3.1.4.1 梯度计算\n",
    "\n",
    "在Logistic回归中，风险函数$\\cal R(\\mathbf w,b)$ 关于参数$\\mathbf w$和$b$的偏导数为：\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\frac{\\partial \\cal R(\\mathbf w,b)}{\\partial \\mathbf w} = -\\frac{1}{N}\\sum_{n=1}^N \\mathbf x^{(n)}(y^{(n)}- \\hat{y}^{(n)}) = -\\frac{1}{N} \\mathbf X^ \\mathrm{ T }  (\\mathbf y-\\hat{\\mathbf y})\n",
    "\\end{aligned}，（3.6）\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\frac{\\partial \\cal R(\\mathbf w,b)}{\\partial b} = -\\frac{1}{N}\\sum_{n=1}^N (y^{(n)}- \\hat{y}^{(n)}) = -\\frac{1}{N} \\mathbf {sum}(\\mathbf y-\\hat{\\mathbf y})\n",
    "\\end{aligned}。（3.7）\n",
    "$$\n",
    "\n",
    "通常将偏导数的计算过程定义在Logistic回归算子的`backward`函数中，代码实现如下:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class model_LR(op.Op):\n",
    "    def __init__(self, input_dim):\n",
    "        super(model_LR, self).__init__()\n",
    "        # 存放线性层参数\n",
    "        self.params = {}\n",
    "        # 将线性层的权重参数全部初始化为0\n",
    "        self.params['w'] = paddle.zeros(shape=[input_dim, 1])\n",
    "        # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])\n",
    "        # 将线性层的偏置参数初始化为0\n",
    "        self.params['b'] = paddle.zeros(shape=[1])\n",
    "        # 存放参数的梯度\n",
    "        self.grads = {}\n",
    "        self.X = None\n",
    "        self.outputs = None\n",
    "\n",
    "    def __call__(self, inputs):\n",
    "        return self.forward(inputs)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        self.X = inputs\n",
    "        # 线性计算\n",
    "        score = paddle.matmul(inputs, self.params['w']) + self.params['b']\n",
    "        # Logistic 函数\n",
    "        self.outputs = logistic(score)\n",
    "        return self.outputs\n",
    "\n",
    "    def backward(self, labels):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - labels：真实标签，shape=[N, 1]\n",
    "        \"\"\"\n",
    "        N = labels.shape[0]\n",
    "        # 计算偏导数\n",
    "        self.grads['w'] = -1 / N * paddle.matmul(self.X.t(), (labels - self.outputs))\n",
    "        self.grads['b'] = -1 / N * paddle.sum(labels - self.outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 3.1.4.2 参数更新\n",
    "\n",
    "在计算参数的梯度之后，我们按照下面公式更新参数：\n",
    "\n",
    "$$\n",
    "\\mathbf w\\leftarrow \\mathbf w - \\alpha \\frac{\\partial \\cal R(\\mathbf w,b)}{\\partial \\mathbf w}，（3.8）\n",
    "$$\n",
    "$$\n",
    "b\\leftarrow b - \\alpha \\frac{\\partial \\cal R(\\mathbf w,b)}{\\partial b}，（3.9）\n",
    "$$\n",
    "\n",
    "其中$\\alpha$ 为学习率。\n",
    "\n",
    "将上面的参数更新过程包装为优化器，首先定义一个优化器基类`Optimizer`，方便后续所有的优化器调用。在这个基类中，需要初始化优化器的初始学习率`init_lr`，以及指定优化器需要优化的参数。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from abc import abstractmethod\r\n",
    "\r\n",
    "# 优化器基类\r\n",
    "class Optimizer(object):\r\n",
    "    def __init__(self, init_lr, model):\r\n",
    "        \"\"\"\r\n",
    "        优化器类初始化\r\n",
    "        \"\"\"\r\n",
    "        # 初始化学习率，用于参数更新的计算\r\n",
    "        self.init_lr = init_lr\r\n",
    "        # 指定优化器需要优化的模型\r\n",
    "        self.model = model\r\n",
    "\r\n",
    "    @abstractmethod\r\n",
    "    def step(self):\r\n",
    "        \"\"\"\r\n",
    "        定义每次迭代如何更新参数\r\n",
    "        \"\"\"\r\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "然后实现一个梯度下降法的优化器函数`SimpleBatchGD`来执行参数更新过程。其中`step`函数从模型的`grads`属性取出参数的梯度并更新。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class SimpleBatchGD(Optimizer):\n",
    "    def __init__(self, init_lr, model):\n",
    "        super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)\n",
    "\n",
    "    def step(self):\n",
    "        # 参数更新\n",
    "        # 遍历所有参数，按照公式(3.8)和(3.9)更新参数\n",
    "        if isinstance(self.model.params, dict):\n",
    "            for key in self.model.params.keys():\n",
    "                self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.5 评价指标\n",
    "\n",
    "在分类任务中，通常使用准确率（Accuracy）作为评价指标。如果模型预测的类别与真实类别一致，则说明模型预测正确。准确率即正确预测的数量与总的预测数量的比值：\n",
    "\n",
    "$$\n",
    "\\mathcal{A} \n",
    "= \n",
    "\\frac{1}{N}\n",
    "\t\\sum_{n=1}^N\n",
    "    I\n",
    "    \t(y^{(n)} = \\hat{y}^{(n)}),（3.10）\n",
    "$$\n",
    "\n",
    "其中$I(·)$是指示函数。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy is: Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [0.50000000])\n"
     ]
    }
   ],
   "source": [
    "def accuracy(preds, labels):\n",
    "    \"\"\"\n",
    "    输入：\n",
    "        - preds：预测值，二分类时，shape=[N, 1]，N为样本数量，多分类时，shape=[N, C]，C为类别数量\n",
    "        - labels：真实标签，shape=[N, 1]\n",
    "    输出：\n",
    "        - 准确率：shape=[1]\n",
    "    \"\"\"\n",
    "    # 判断是二分类任务还是多分类任务，preds.shape[1]=1时为二分类任务，preds.shape[1]>1时为多分类任务\n",
    "    if preds.shape[1] == 1:\n",
    "        # 二分类时，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0\n",
    "        # 使用'paddle.cast'将preds的数据类型转换为float32类型\n",
    "        preds = paddle.cast((preds>=0.5),dtype='float32')\n",
    "    else:\n",
    "        # 多分类时，使用'paddle.argmax'计算最大元素索引作为类别\n",
    "        preds = paddle.argmax(preds,axis=1, dtype='int32')\n",
    "    return paddle.mean(paddle.cast(paddle.equal(preds, labels),dtype='float32'))\n",
    "\n",
    "# 假设模型的预测值为[[0.],[1.],[1.],[0.]]，真实类别为[[1.],[1.],[0.],[0.]]，计算准确率\n",
    "preds = paddle.to_tensor([[0.],[1.],[1.],[0.]])\n",
    "labels = paddle.to_tensor([[1.],[1.],[0.],[0.]])\n",
    "print(\"accuracy is:\", accuracy(preds, labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.6 完善Runner类\n",
    "\n",
    "基于RunnerV1，本章的RunnerV2类在训练过程中使用梯度下降法进行网络优化，模型训练过程中计算在训练集和验证集上的损失及评估指标并打印，训练过程中保存最优模型。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 用RunnerV2类封装整个训练过程\n",
    "class RunnerV2(object):\n",
    "    def __init__(self, model, optimizer, metric, loss_fn):\n",
    "        self.model = model\n",
    "        self.optimizer = optimizer\n",
    "        self.loss_fn = loss_fn\n",
    "        self.metric = metric\n",
    "        # 记录训练过程中的评价指标变化情况\n",
    "        self.train_scores = []\n",
    "        self.dev_scores = []\n",
    "        # 记录训练过程中的损失函数变化情况\n",
    "        self.train_loss = []\n",
    "        self.dev_loss = []\n",
    "\n",
    "    def train(self, train_set, dev_set, **kwargs):\n",
    "        # 传入训练轮数，如果没有传入值则默认为0\n",
    "        num_epochs = kwargs.get(\"num_epochs\", 0)\n",
    "        # 传入log打印频率，如果没有传入值则默认为100\n",
    "        log_epochs = kwargs.get(\"log_epochs\", 100)\n",
    "        # 传入模型保存路径，如果没有传入值则默认为\"best_model.pdparams\"\n",
    "        save_path = kwargs.get(\"save_path\", \"best_model.pdparams\")\n",
    "        # 梯度打印函数，如果没有传入则默认为\"None\"\n",
    "        print_grads = kwargs.get(\"print_grads\", None)\n",
    "        # 记录全局最优指标\n",
    "        best_score = 0\n",
    "        # 进行num_epochs轮训练\n",
    "        for epoch in range(num_epochs):\n",
    "            X, y = train_set\n",
    "            # 获取模型预测\n",
    "            logits = self.model(X)\n",
    "            # 计算交叉熵损失\n",
    "            trn_loss = self.loss_fn(logits, y).item()\n",
    "            self.train_loss.append(trn_loss)\n",
    "            # 计算评价指标\n",
    "            trn_score = self.metric(logits, y).item()\n",
    "            self.train_scores.append(trn_score)\n",
    "            # 计算参数梯度\n",
    "            self.model.backward(y)\n",
    "            if print_grads is not None:\n",
    "                # 打印每一层的梯度\n",
    "                print_grads(self.model)\n",
    "            # 更新模型参数\n",
    "            self.optimizer.step()\n",
    "            dev_score, dev_loss = self.evaluate(dev_set)\n",
    "            # 如果当前指标为最优指标，保存该模型\n",
    "            if dev_score > best_score:\n",
    "                self.save_model(save_path)\n",
    "                print(f\"best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}\")\n",
    "                best_score = dev_score\n",
    "            if epoch % log_epochs == 0:\n",
    "                print(f\"[Train] epoch: {epoch}, loss: {trn_loss}, score: {trn_score}\")\n",
    "                print(f\"[Dev] epoch: {epoch}, loss: {dev_loss}, score: {dev_score}\")\n",
    "                \n",
    "    def evaluate(self, data_set):\n",
    "        X, y = data_set\n",
    "        # 计算模型输出\n",
    "        logits = self.model(X)\n",
    "        # 计算损失函数\n",
    "        loss = self.loss_fn(logits, y).item()\n",
    "        self.dev_loss.append(loss)\n",
    "        # 计算评价指标\n",
    "        score = self.metric(logits, y).item()\n",
    "        self.dev_scores.append(score)\n",
    "        return score, loss\n",
    "\n",
    "    def predict(self, X):\n",
    "        return self.model(X)\n",
    "\n",
    "    def save_model(self, save_path):\n",
    "        paddle.save(self.model.params, save_path)\n",
    "\n",
    "    def load_model(self, model_path):\n",
    "        self.model.params = paddle.load(model_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.7 模型训练\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "下面进行Logistic回归模型的训练，使用交叉熵损失函数和梯度下降法进行优化。\n",
    "使用训练集和验证集进行模型训练，共训练 500个epoch，每隔50个epoch打印出训练集上的指标。\n",
    "代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best accuracy performence has been updated: 0.00000 --> 0.73750\n",
      "[Train] epoch: 0, loss: 0.693359375, score: 0.4999999701976776\n",
      "[Dev] epoch: 0, loss: 0.6839081048965454, score: 0.737500011920929\n",
      "best accuracy performence has been updated: 0.73750 --> 0.74375\n",
      "best accuracy performence has been updated: 0.74375 --> 0.75000\n",
      "best accuracy performence has been updated: 0.75000 --> 0.75625\n",
      "[Train] epoch: 50, loss: 0.48008108139038086, score: 0.7906250357627869\n",
      "[Dev] epoch: 50, loss: 0.5083038210868835, score: 0.7562500238418579\n",
      "best accuracy performence has been updated: 0.75625 --> 0.76250\n",
      "[Train] epoch: 100, loss: 0.4374733865261078, score: 0.8062500357627869\n",
      "[Dev] epoch: 100, loss: 0.47221413254737854, score: 0.7562500238418579\n",
      "[Train] epoch: 150, loss: 0.42071062326431274, score: 0.8109375238418579\n",
      "[Dev] epoch: 150, loss: 0.45897427201271057, score: 0.7562500238418579\n",
      "[Train] epoch: 200, loss: 0.41218772530555725, score: 0.8109375238418579\n",
      "[Dev] epoch: 200, loss: 0.45284023880958557, score: 0.75\n",
      "[Train] epoch: 250, loss: 0.40726566314697266, score: 0.8140624761581421\n",
      "[Dev] epoch: 250, loss: 0.4496605098247528, score: 0.7562500238418579\n",
      "[Train] epoch: 300, loss: 0.4041973650455475, score: 0.8156249523162842\n",
      "[Dev] epoch: 300, loss: 0.4479003846645355, score: 0.7625000476837158\n",
      "[Train] epoch: 350, loss: 0.40217551589012146, score: 0.815625011920929\n",
      "[Dev] epoch: 350, loss: 0.4469268023967743, score: 0.7625000476837158\n",
      "[Train] epoch: 400, loss: 0.4007957875728607, score: 0.815625011920929\n",
      "[Dev] epoch: 400, loss: 0.4464201033115387, score: 0.7625000476837158\n",
      "[Train] epoch: 450, loss: 0.39985084533691406, score: 0.8187499642372131\n",
      "[Dev] epoch: 450, loss: 0.44611817598342896, score: 0.7625000476837158\n",
      "best accuracy performence has been updated: 0.76250 --> 0.76875\n"
     ]
    }
   ],
   "source": [
    "# 固定随机种子，保持每次运行结果一致\n",
    "paddle.seed(102)\n",
    "\n",
    "# 特征维度\n",
    "input_dim = 2\n",
    "# 学习率\n",
    "lr = 0.1\n",
    "\n",
    "# 实例化模型\n",
    "model = model_LR(input_dim=input_dim)\n",
    "# 指定优化器\n",
    "optimizer = SimpleBatchGD(init_lr=lr, model=model)\n",
    "# 指定损失函数\n",
    "loss_fn = BinaryCrossEntropyLoss()\n",
    "# 指定评价方式\n",
    "metric = accuracy\n",
    "\n",
    "# 实例化RunnerV2类，并传入训练配置\n",
    "runner = RunnerV2(model, optimizer, metric, loss_fn)\n",
    "\n",
    "runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_epochs=50, save_path=\"best_model.pdparams\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可视化观察训练集与验证集的准确率和损失的变化情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xmc3FWV///Xqa3XdKeTdLbOHhISQlgkBGSRoASisowwYICvAw6IoCiiP78gM6BfcAE3QMQFGGTQEVRQCE5kEwRZhCSAhCyQjYQ0WTp70ltt5/dHVTrVW9Idqqsq3e/n49EPqu79fKpOEihObp17rrk7IiIiIiKSEsh3ACIiIiIihUQJsoiIiIhIBiXIIiIiIiIZlCCLiIiIiGRQgiwiIiIikkEJsoiIiIhIBiXIIiIiIiIZlCCLiIiIiGRQgiwiIiIikiGU7wB6wqBBg3zMmDH5DkNEpJUFCxZscvfqfMeRK/osFpFC09XP4V6ZII8ZM4b58+fnOwwRkVbMbHW+Y8glfRaLSKHp6uewSixERERERDIoQRYRERERyZCzBNnMZpnZ22a23Myu7WD+VjN7I/3zjplty5i7yMyWpX8uylXMIiIiItL35KQG2cyCwJ3ATGAtMM/M5rj74t3XuPvVGdd/CTgy/XgA8E1gGuDAgvS9W3MRu4iIiIj0LblaQZ4OLHf3le4eBR4EztrL9ecDD6QfnwY85e5b0knxU8CsHo1WRERERPqsXHWxqAHey3i+FjimowvNbDQwFnhmL/fWdHDfZcBlAKNGjfrgEYv0gB07drBx40ZisVi+Q5EsCofDDB48mIqKinyHIiIiWVCIbd5mAw+5e6I7N7n7XcBdANOmTfOeCEzkg9ixYwcbNmygpqaGkpISzCzfIUkWuDuNjY3U1tYCKEkWEekFclViUQuMzHg+Ij3WkdnsKa/o7r0iBWvjxo3U1NRQWlqq5LgXMTNKS0upqalh48aN+Q5HRESyIFcJ8jxggpmNNbMIqSR4TtuLzGwSUAW8nDH8BHCqmVWZWRVwanpM5IASi8UoKSnJdxjSQ0pKSlQ6IyLSS+SkxMLd42Z2JanENgjc6+6LzOxGYL67706WZwMPurtn3LvFzG4ilWQD3OjuW3IRt0i2aeW499KfrYhI75GzGmR3nwvMbTN2Q5vn3+rk3nuBe3ssOCD29iYC5RGCNaofFBERkb7BYwni72wGP/C2bwUGlxEcXN4jr12Im/Tyom763ZR+9gj63/bxfIciIiIikhPb/+9T1N/2j3yHsV/63XQyFf95Uo+8thLktEBFEb6jOd9hiPQ5S5cuZfLkycybN49p06bt9+s8/vjjfPzjH6euro5BgwZlMUIR6au2fv4xoi+s6XAuWNOPgY9dgBX1bCqV3NHE5jMeILmpocP54k9MoPIHp+7zdZqfWcm2rzwOidYrxfEVWyiadRBllxyZlXhzKTRlcM+9do+98gHGKopIKkEWaWdftbWjR4/m3Xff3e/XnzBhAuvWrVNSK9JHeDxB/U9fJbmjmfDUIZR8anJ2X9+dhrsXkFi/64O9TmOchrsWED52BMERrcsvfVeU5seXs+3yPxMc2x8rCVP2xaNp/M2bJNbvIjSmP6X/dsSe65NJ6n8xv9MkF8BCAUov/VC7koGG37xJ9PnVFJ95MESCreYSK7ey68cvYyUhCO3puxDoX0zZF6djwQCxJXU0/mERjQ8vIbluF5EZY1q9RviwIfT75kmEJ1V397eoV1OCnBao1AqySEfWrVvX8vill17inHPO4bXXXmPYsGEABIPBDu+LRqNEIpF9vn4wGGTo0KHZCVZE8i6+ZhveFO90vvnJFWy/Ot2MKhSg+uVLsIqi7L3/mxvY9vk/Z+W1AtWlDJxzPsHqslbjnkxSN+0uGu57o2UsNq+Wxj8s3nPv0HKCY/qn5l6tZfsXW23D6jj2Vdso//pxrcbqf7mA8JFDGfDI7HYLFvF3t7LxiF+w86bn272WlYSJnDSabZf/mejzqwGovH0W5V8+dp9xiBLkFlZRRHJbU77DECk4mcnrgAEDAKiurm6X1A4dOpQrrriC2tpaHnroIaZOncpzzz3HD3/4Q+6//35WrFhBZWUlH/3oR/nxj3/M4MGpr8balljsfv7www9z991389xzzzF8+HBuvPFGLrjggm7F/sILL3Dttdcyf/58SktLOf3007n11lsZOHAgAKtXr+aqq67i73//Ow0NDdTU1PClL32Jq666CoCHHnqIm266iWXLllFUVMSkSZO4++67OfTQQ/f791OkN2t87G22nPnAPq8Ljqti4GPns3HKz6g7+u6sx2GVRQxd+1WsNPwBX8g6/BbNAgGqF3y+ZWNb3bH30PiHxVhlEYPfvIINE+9g82m/aXVPoLqUoWuubrcKvNvW//NHGu55jYZ7Xms31/8Xp3cYR2hMFcO2Xtt6g13C2TD+drZd9ljLUMV3Pkr5tSdggVx19z3wKUFOC1QUkVizPd9hSB+z7St/IfbG+py/b/iIoT2yIfVHP/oR1157La+88gqJROowTDPjtttuY+zYsbz//vtcffXVfOYzn+GJJ/bezvyaa67hlltu4Y477uAXv/gFF198MccddxxjxozpUizvvfcep512Gueeey6//OUv2bRpE5dffjmzZ8/mqaeeAuBzn/scwWCQZ555hsrKSlasWMHmzZsBWLNmDbNnz+ZHP/oRZ555Jo2NjSxYsKDTFXORXNv+H3+lee6yPQNBo/KHp1I0Y2xW36fxj4vZ+e3nwSEwpIwBf/w0gdLUt0MNDyxk1/dfbLk2sXYHgZp+VH5/5l5fMzxtOOGJgxj0t4tJ1O7IarwAoUOqCZRnb1W6I2YG6aR1wB/OI/riGkKHVBMa1Z/q5z9LfHnrjrThqUOw4s4T9sqffJziMw5u103CikIUn3Vwl+IAIAADn/gMsddT3/5ZOEjxGROVHHeTEuQ01SCLfHAnnngi1113Xauxr33tay2Px44dy+23385xxx3H5s2bW1ZyO3L11Vdz9tlnA/Dd736XO+64g+eee67LCfJPfvIThgwZwj333EMolPqou++++zj22GN59dVXmT59OqtXr+azn/0shx9+OECr166trSWZTHLeeee1lJMccsghXXpvkZ7U+OhS4m9tZNctLxCaMphQ+mv85hfWsP3qJyj59BQArF8RZZ8/Cgt1/y91HktQ/4v5eH2U+rtfw5vjhA+ppvmJFWy/ci6hian/dut/ljqiIHxkuuRqVCWl/3Y4Jed07b+VopPGdDu2QhQa3Z/Q6P4tzyPTRxCZPqJbrxEcVEbp+VOzEk94cjXhyaop/iCUIKeZulhIHvS2toLTp09vN/b0009zyy23sHTpUrZt20YymQRS5Q17S5CPOGLPBpdIJMKgQYPYsGFDl2NZtGgRxx13XEtyvDu+4uJiFi1axPTp0/nqV7/KlVdeyaOPPsqMGTM4/fTTOf744wE4+uijOemkkzj44IOZOXMmM2bM4Oyzz6ampqbLMYhkS6KuHt8VJbmlkS3n/A4SjpWFGfinTxMalyp92nXby2y/+onW30oFjOJZB3X7/ZrmvM32rzyeemJQ9dtzKPn0odQdczcNv9pTd4vBgD/NpuSsSR/klydScJQgpwUqivCdUTyZ1NcQIvuprKz1Rpbly5dz+umnc+mll/L//t//Y+DAgaxYsYJPfvKTRKPRvb5W2w1+ZtaSXGfL5z//eT75yU/y+OOP8+yzzzJz5kwuuOCCllXnZ555hldeeYWnn36aBx98kGuuuYZHH32UmTP3/vWxSDbFFm9k42E/39Oey2Dwki8SOmhAq9Xh8q98mLIrjgZ3POlsnPpztn/hf9nf4sHQpEEMfu3zEDQskkoXqv9xKUQTey4K7JkT6U30b/VuQ8KEPzIc3xXFKorzHY1Ir/DKK68Qi8W47bbbWlZyX3zxxX3clR1Tpkzh4YcfJh6Pt7z3q6++SlNTU6tNdiNGjODSSy/l0ksv5b777uPf//3fufPOOykqKsLMOPbYYzn22GP5z//8T2bMmMF9992nBFm6JbFuJ1sufBivj3U4b2VhBvzmbILDOz7Jtf6XCyAYoP8vPwmhAKFRlZ225Nrdk9eAgX++gOirtfsdd+TDI7CS1jWzFghAsRaRpPdTgrxbEQQPrkqVWShBFsmKiRMnkkwmufXWW/nXf/1XXnvtNb73ve/l5L2vuuoqfvazn3HppZfy9a9/nU2bNnHFFVdwyimncPTRRwNw+eWX8y//8i9MmDCBxsZGHnnkEcaPH09RURF/+9vfeOmllzjllFMYOnQoS5cuZfHixUqOpZXmZ1cRTW+GKjphVKu606YnlxN7ayPRF98j+rd3KTp1fOvNVADuND+5gm1XziVywqgO36Ph/n9Scs5kyi75ULdiUx2qyP5TgrxbMICVh0juaEZ71EWy4+ijj+bHP/4xP/rRj7jhhhs45phjuPXWWznjjDN6/L1HjBjBE088wTXXXMNRRx3Vqs3bbolEgi996UusXbuW0tJSjjvuOB57LNUaqaqqiueff57bb7+dbdu2MWzYMC655BKuueaaHo9dCpcnkpBIQjhI4t1tbD7jty0rw4Hh/aj+x6VYwEjubGbzmQ9Ac6ocofjsyQx8+NMdvubmc39P00OLafrT0o7fNGCUXdm+vl9Eeo55m3YivcG0adN8/vz53bpn529fIb6kjrJPHk7k2JE9FJn0ZUuWLGHy5OyeGCWFZV9/xma2wN33/zztA8z+fBYXuq0X/4mmJ1dQ/pVj2XHN0wAMeu5iEut3sfXTD7W7vvqVSwlNGoSVRzrd3+Lu+M7ON4lbONiu1EFE9k9XP4e1gpxmkRBWGlarNxHp1cxsFnA7EATucfeb28yPAv4b6J++5lp3n5ue+wZwCZAAvuzue29m3cvU/2IeDf/9TwB2fPNvhI8aRr8bTqLoI2Nwd3BadUMK1vTrUqsvM9PeF5ECowQ5LVBahEcTavUmIr2WmQWBO4GZwFpgnpnNcffFGZf9J/B7d/+5mR0CzAXGpB/PBqYAw4GnzWyiuyfoA7wpxvb/eAYCRvjo4QQqilLJ8QmjgVSSW/ppnbAo0lsoQU6LHDqCrZ98iMg9Q/d9sYjIgWk6sNzdVwKY2YPAWUBmguzA7nYKlcD76cdnAQ+6ezOwysyWp1/v5VwEng/eFCO5M9WOsOmRpfiWRgb99d8o+ui4PEcmIj1NCXJaoCJ1JKVWkEWkF6sB3st4vhY4ps013wKeNLMvAWXAKRn3/qPNvb321JRkQ5QN439Ccv2ulrHgQQOIzBiTv6BEJGeUIKclGpooufpwkvVKkEWkTzsfuM/df2RmHwZ+bWZdrh0ws8uAywBGjeq4bVmh2XH9MzS/uKbVmG9vJrl+F/3+40QCw/oBUHTiKB0kJdJHKEHeLZ4kNHUQvrwp35GIiPSUWiCzTc+I9FimS4BZAO7+spkVA4O6eC/ufhdwF6S6WGQt8h4SX7mFnd9+ntCkQQSqS1vGrSxM6b8fSb+bPoq17V0sIr2eEuS03acPJZs7PulIRKQXmAdMMLOxpJLb2cAFba5ZA3wMuM/MJgPFQB0wB/itmf2Y1Ca9CcCruQq8pzSmew8PfPIzhEZW5jkaESkUSpDTdifIxPrEhmwR6YPcPW5mVwJPkGrhdq+7LzKzG4H57j4H+Bpwt5ldTWrD3sWeapi/yMx+T2pDXxz4Ym/oYBGb/z7BUZVKjkWkFSXIaRZJNWH3xAH/eS8i0ql0T+O5bcZuyHi8GDi+k3u/A3ynRwPMsei8WsJHDct3GCJSYLTbIM2KQvjOGL5LJRYihejiiy/mlFNO2feFIl20685XSazYStFHx+Y7FBEpMEqQ0ywYIP5cHfEFdfkORaTgXHzxxanTvswIh8MMGjSIE044ge9///vU19fnOzyRbou9s4ntV6YW0ksvPCzP0YhIoVGCnCFQUaQ+yCKdOPHEE1m3bh2rV6/m2Wef5cILL+SnP/0pH/rQh9iwYUO+wxPpssTGXWw8+KcADH7rCwSqSvIckYgUGiXIGQJTKgidPDzfYYgUpEgkwtChQxk+fDhTp07liiuu4OWXX6auro5rr7221bV33HEHkyZNori4mAkTJvCd73yHeDwOwH/8x39w8MEHt3v9K664ghNOOKHL8bg7P/zhDxk3bhyRSITx48dz2223tbrm0Ucf5cgjj6S0tJT+/fszffp0Xn/9dQBisRhf/epXGTFiBEVFRQwbNozZs2d397dF8iw6r5bNZz9I8zMrW8YaH17M5nN+R+ydTR3e03DfGwBU3j6L8JTBOYlTRA4s2qSXwUqDBIaV4u7qeyk5U/+XN9uNhccMIjJ5OB5P0PDUovbzBw0hMmEIyaYYjc8uaTcfOXgY4XHVJHc10/j3t9vNl308O18p19TUcOGFF3L//ffzX//1XwQCAb71rW/xq1/9ittuu40jjjiCJUuWcPnll9PU1MRNN93ERRddxHe/+11eeeUVjjkmdYhbc3Mzv/vd77j55pu7/N4/+9nPuP7667n99ts5+eST+etf/8pXvvIV+vXrxyWXXML69es599xz+fa3v825555LU1MTr7/+OqFQ6mPvjjvu4Pe//z2/+c1vGDduHBs2bODFF1/Myu+L9LzE+ztofvZd6n82j+hL7xFfvoXK751C0ayD2P6Vx0ms3YE3xel33YlEjhpG45y3IZYEoP6XC4icOIryLx+b51+FiBQqJciZAgGsNIQ3xLCySL6jETkgTJkyhR07drBp0ybKy8v5/ve/zx//+EdmzZoFwNixY/n2t7/Nl7/8ZW666SYmTpzIMcccw/3339+SID/22GM0NjZy3nnndfl9b775Zr70pS9x2WWXATBhwgTefvttvvOd73DJJZewbt06YrEY5513HmPGjAFg8uTJLfevXr2aiRMnctJJJ2FmjBo1iqOPPjpLvyvS07b++6M0P7ECgODICuILN7L59N9SdvWxJNbuIDC0nOa5y2h+YjllVxxN/U9bt2yu+N7H8hG2iBwglCBnsFAQKw+n6pCVIEuO7G0110LBvc4HisN7ny8vytpqcWdSLXLBzFi0aBGNjY2cc845rb6FSSQSNDU1UVdXR3V1NRdddBHXX389t912G+FwmPvvv58zzzyT/v37d+k9d+zYwdq1a/nIRz7Savykk07i9ttvp6GhgcMOO4zTTjuNQw89lJkzZzJjxgzOPvtsRo5MHQb32c9+lpkzZ3LQQQcxc+ZMZs6cyRlnnEEkov/2C1181Vaan1hB+f93HGWXTyM4pj+JVVvZeMw91N/6DwJDyhi68iqiC95n04m/ov6nrxI5cRRV/3VW6gUiQYKj1PdYRDqnGuRMkRBWFiKxrTHfkYgcMBYtWkRlZSUDBw4kmUx9hf2HP/yBN954o+Vn4cKFLFu2jAEDBgAwe/Zsdu7cyf/+7/9SV1fH448/zkUXXZTVuILBIH/5y1945plnOProo3n44YeZOHEif/7znwE44ogjWLVqFT/84Q+JRCJcddVVHHHEEezYsSOrcUj21d/zGgSM8quOITR+ABYMEDpoIAMfOo9+N57MgN+fi5WEKTphNFUP/isV3/4o/e86g9CEgamf0f1VRicie6UV5AyBsiJib63HpzblOxSRA0JtbS3/8z//w9lnn00gEGDKlCkUFxezcuVKPvGJT3R6X1VVFWeccQa//vWvWbNmDQMGDOC0007r8vtWVFQwYsQInn/+eU4//fSW8eeee46xY8dSWloKpFa1p0+fzvTp07nuuuuYNWsWv/rVr1ruKS8v51Of+hSf+tSnuO666xg2bBjPPfccZ5xxxn7+jkhP8kSSprnLaLj3dYo/OYHgiNarwEUnj6Xo5NY9jUs/fWguQxSRXkIJcobQ8AFs+8GfKD158r4vFuljotEo69evJ5lMsnnzZl544QW+973vMXjwYL73ve8BqYTzuuuu47rrrsPMOOWUU4jH4yxcuJDXX3+dW265peX1/u3f/o1zzz2XJUuWcOGFFxIMBrsVzze+8Q2+9rWvMWHCBGbMmMEzzzzDz3/+c+68804AXnrpJf76179y6qmnMmzYMJYtW8abb77JJZdcAsAPfvADhg8fzhFHHEFpaSkPPPAAwWCQiRMnZul3TLKt4Vevs+1zjwFQ9gXVi4tIz1GCnCFQVQxAcptWkEXa+vvf/86wYcMIBoNUVlYyefJkrrzySr74xS9SVlbWct3111/PsGHD+OlPf8rXvvY1SkpKmDhxIhdffHGr1/v4xz9OZWUlS5Ys4YEHHuh2PFdccQX19fV897vf5Qtf+AIjR47k5ptvbkmAKysrefnll7nzzjvZunUrQ4cO5cILL+T6668HUqvQP/7xj1m2bBnJZJLJkyfz8MMPd9iCTvLLk0nqjr2H2Lz3CU2pZuCc8wmNG5DvsESkF7PdG2x6k2nTpvn8+fO7fV/0nY00PPwawar+9Ltc7X8ku5YsWdKqi4L0Pvv6MzazBe4+LYch5dX+fha31fTXlWw+5X5KPnMY5V8+hsi0mixEJyJ9UVc/h7WCnCFQWUxgaBm+JZrvUEREJK3hrgXYgBKq7joDKw7nOxwR6QPUxSJDoCJVYuHNsTxHIiIikDoWuvFPSyi96HAlxyKSM0qQM1hRGE86HkvkOxQRESF9LHQsSdnnjsp3KCLShyhBzmABg+YEnu7lKiIi+ePJJPV3v0bkI6MJT67Odzgi0ofkLEE2s1lm9raZLTezazu55jwzW2xmi8zstxnjCTN7I/0zpyfjTK6px+t0UIj0jN64KVZS9Gebfc3Pvkti+RbKLtPqsYjkVk426ZlZELgTmAmsBeaZ2Rx3X5xxzQTgG8Dx7r7VzAZnvESjux+Ri1iTi3aQqNVJWpJ94XCYxsbGlkMspHdpbGwkHFaNbDbt3pxXco66v4hIbuVqBXk6sNzdV7p7FHgQOKvNNZ8D7nT3rQDuvjFHsbViVcUkt6oPsmTf4MGDqa2tpaGhQauNvYi709DQQG1tLYMHD973DbJX2678X7Z+9hFtzhORvMpVm7ca4L2M52uBY9pcMxHAzF4EgsC33P3x9Fyxmc0H4sDN7v5I2zcws8uAywBGjRq134EGJ1dSfNiU/b5fpDMVFRUAvP/++8Ri6pTSm4TDYYYMGdLyZyz7r/7OeQAk1mzX5jwRyZtC6oMcAiYAM4ARwPNmNtXdtwGj3b3WzMYBz5jZQndfkXmzu98F3AWp5vT7G4QVh6DCSMYTBELdO/pWZF8qKiqURInshZWG8YYYsaWbKPnMYdqcJyIAJBuiJLfVtzwPDu2faq7QQ3KVINcCIzOej0iPZVoLvOLuMWCVmb1DKmGe5+61AO6+0sz+BhwJrKAHWFEIAkl8cwMM6dcTbyEiIp0IHTyQ4IgKBs65IN+hiEgBaXxuKYn121ue9/s/x0Gg5xYyc1WDPA+YYGZjzSwCzAbadqN4hNTqMWY2iFTJxUozqzKzoozx44HF9JTSCACJul099hYiItIJleeLSAeSu5oI1lRR+onDKP3EYRDs2RQ2JyvI7h43syuBJ0jVF9/r7ovM7EZgvrvPSc+damaLgQTwdXffbGbHAb80sySphP7mzO4X2RYoLyKxs4nkloaeegsREemMO1jPfW0qIgced4dEkmBVGaEhlTl5z5zVILv7XGBum7EbMh478NX0T+Y1LwFTcxEjQLCqlKa5SwgNUd2biEheKD8WkQxmRr/Zx+a0A5RO0msjOLgfTb9agjXouGkRkVxTB0QR6Yzl8NulQupiURACVcUAJLbqND0RkbwowBKLZEMzDX9ZiMfiZC5xW1kR5WekzrFqeHYJiQ2ZB005Vhyh7JOHY2F1ReoJ8fe30vjCMkim/mYVGt6fko8cDMCuR1/DG1u31AyNGkDJcRNS8w/Nw+PJVvPh8dUUHz0OgJ0PvtLu/SIHD6XoyNF4LMGuh+e3nz+0hqJDR5BsjFL/6Ovt5ouOGEVk0jCSOxqpn/tm+/lpY4gcNITElnoannyr3Xzxh8cTHj2I+IYdND67pN18yYkTCdVUEa/dSuPf32k/f/JkQkMqiK3eRNPL7XsdlJ56KMEBZURXbKR53qp282WfOIxARQnRpetofmNN+/kzjyRQGqH5rbVE32rbiwHKz5mGhYM0v76a6Nvr2833m53qANw0bxWxFXuOw/DGKMGhlZScMJFAv+J29/UEJchtWP9iym47kWRUCbKISM4V6BJyoLSIklMOIbpwbasE3or2/G80OLgCi+x57k0xwmMHqWSkB8XXb8cbmglPGApAsKqsZS40vD8ebf1tcHBg+Z7HI6og0frft0Dm/SMHtHu/QP/0SahmHc9XlKSmA4GO53cnd+Fgx/PlqXmLdDxv6UYCVhzqeL4k3PLPDueLU/9+BkqLOp6PpP4iFyjreJ50+9tAv+KO709vnAtUlHR8f/q/nUD/0o7n0wJV7ectEmz59eeC9cYTvaZNm+bz57f/m11XuDvbv/8kVlxE5VUzshuYiPRpZrbA3aflO45c2Z/P4g1Tf0ZowgAG/nF2D0UlvUnjy8uJr9lMv0+3PXtMpGNd/RxWDXIbZoY3JcCT+75YRESyrwBLLGKrN9E0f1W3Ngl5Mkls9SYSGYcbSHaVfPggyv/16HyHIb2QEuSONCf1OyMikg8F+q1mfO1WYss2dHuTUOMzS4iv2tRDUQns+VpfJJtUg9wBjyUhrP/gRETyogcXkN2d6MK1eHOc4MBywuNSLT2bFrzbstErOKSC8KiBAESXvE9yVzOJ9du7Xf9ogQBWHCb23hY8nsTCAYqOGJ163eUbSG5t3W/fikIUHZY6dDb69jqSO5paz5dGKJpSk5pf/D7J+uZW84F+RUQmDQeg+a21ezaoBY2iKTVYUbhb8ReC5K4mEht37vlzeu3dVnXDsdWbKD5qDOGxas0q2aUEuQO+JUaifgvuntOWIiIifV4PLyAnt9TTvOBdCBjh8YNbEq/o0nWQSEIyib1b1JIgx1bVkdiUOlk1cvDQbr9fcFgl8TVbiG5rwIrDLQly/L0txN/b0uraQHlRS4IcX72ZeMaxupDauLQ7QY69uyeulveq7teSIMdWbCS5vRFwSDh2PB+yAAAgAElEQVSBfiVEJgzpdvz5Fn1nPbF3NhAaOwgzI/b2ejzWeuOdJwvzWwc5sClB7oA1Q/TZNUqORUTyoQc/e5MNUQBKP34YocEVLeMVF34YSLWXii6uJZZOXss+cfgHer/SGZM7Hj+54/GW+VMP3ev8vuIqP+tDAHg8wc5fv4Q3NO/1+kLl6T+v3f8/7nf+sfkMR/oQ1RF0IDColGRTDI/rsBAR6T3MbJaZvW1my83s2g7mbzWzN9I/75jZtoy5RMbcnB4LsodrkL0xlXAFOimXCA4qJzRyANF/riG68L0ejSUXLBSk5KRJhMYMynco+yXZEM1pay+R3bSC3IHAsFLKv3Ms8fe2qK5JRHoFMwsCdwIzgbXAPDOb4+6Ld1/j7ldnXP8l4MiMl2h09yN6PFDv2SYWVhQmOKw/VtJx0hUeW014bDW7Hp5PYEBZh9ccaHaXkRyIvDFKoKwo32FIH6QEuQNWUYLTTGJTvRJkEektpgPL3X0lgJk9CJwFLO7k+vOBb+YottY6yJC9OdZSHhHoV4yFuncynUfjJOubCVb3o2z01L1fG4uTbIgSGlHVrfcoVIkt9STqdhDMKCmxYKDlUIvkjkY80bq1qYUCBPql5hPbGyHZdj7YcuhFYltDu5V/CwdbDr1IbKtvV1tukVBL4pvY2r4NnhWFCZRG8IYoNqhfd3/JIh+YEuQOBAeWEq9vbrfDWETkAFYDZNYMrAU6PF3BzEYDY4FnMoaLzWw+EAdudvdHeiTKTkosYu9uouml5QCERg2k9GOHdOtlG558i0TdTiKHjqD46LGdXpdsjLLrjwsgnsDKc3OkbU+LLq4ltmxDq7HAgLKWOuWG55aSbLvhb0hFS51z418XpTf87RGqqWqpk254YmFLrXDL/JhBLXXW9X/+J7TZWBeeMISSEyam5h99rV0CHTlkOMXHjKf4wwdhZSqxkNxTgtyBYHUZsQ0b27XYERHpI2YDD7l7ZlYz2t1rzWwc8IyZLXT3FW1vNLPLgMsARo0atX/vnrGAHFu7BeJJQsP7U3LyJKJv1ZLc0UjTvFUkNmyn+MMHtTo+uDOJ7Y2ERlQRHj94r9cFSiKUfmwy3hwnNLx3rCAXTRvTbjU880js4qPG4NF46/mMlnDFx4zHY23mM0pUio+bAInWCbCV7imLKDlxYru/+AQy/vJRMmNSu5h3r26HD9DaaTnwKUHuQGBQKckdUQL9o/u+WETkwFALjMx4PiI91pHZwBczB9y9Nv3PlWb2N1L1ye0SZHe/C7gLUkdNdzvKNnfEFr9PsilG+ZlHEuhXQnzddmIr64jXbiW5tZ7okvdbViI7fcl4AqJxgoMrCHahrjg0tH+3wy5kgeIIgTGdlwvu6y8CoZq9z4dHDtj7/Oi9J7nhvcQmki/qYtGBwMASonPfxRr3fa2IyAFiHjDBzMaaWYRUEtyuG4WZTQKqgJczxqrMrCj9eBBwPJ3XLn8g7q136SUbo606TgQHlhOq7tdySEbbr/Y7fM105wp1QxCRrlKC3IHAwFLiL63H67SCLCK9g7vHgSuBJ4AlwO/dfZGZ3WhmZ2ZcOht40L3Vd+KTgflm9k/gWVI1yD2SIAOtSiy8Idrq6/zIxKGUfOwQSJcEJBu78DkdClL0odEEtdlLRLpIJRYdsKIQVl1CYleTTtMTkV7D3ecCc9uM3dDm+bc6uO8lYO+tH7IlIy2PrarDm2LtVn5bTqAzSG5rIPr2OiIHDyPZGKXhybfavWTk0BEUHb6f9dAi0icpQe5E5JRRBCaWpHbeRvTbJCKSM7sXJdwJVJS026gVKCsiNGYQ4dEDia3ahIWDLfd11DO3uy3hRESU+XUm/QGdbIwSVIIsIpIbGZUd4XGDCY9r33UiWN2vpYVY5nygOEzpKVN6PkYR6fVUg9wJC6WSYm+M5TkSEZE+xGmpQfZYAu/ho6dFRDqiBLkTVpLqAdmVHdIiIpJF6W/wdv7uFZrnrcpzMCLSFylB7kSgPFXHlmxoznMkIiJ9R2B0OTayhOaFayGWaFmsEBHJJSXInQj0L6Hx3sUEh1Ts+2IREcmK4OT+BCeU0zw/tXIcHLDvU/JERLJNu886ERxUSvyFdVhcLd5ERHIl9uRarCFA1S/PgICpA4WI5IVWkDsRGFSKDSkhtmpTvkMREek74g5JsEhIybGI5I0S5E4EBpVSdPpYosvX5TsUEZG+Q10rRKQAKEHuRGBgKcktTZBI4El9YIuI5ITvOSdERCRflCB3IlBdim9NdbDwRrV6ExHJGWXIIpJnSpA7ERhUSnJrE6BWbyIiOaMSCxEpAEqQO2GhIJZMrWJ4vVaQRURyRgvIIpJnSpD3JhAg/o9NBIeqF7KISE5oAVlECoAS5L0IDiwj8dYWAsWRfIciItInuGuXnojknxLkvQgMKcNLjHjt1nyHIiLSdyg/FpE8U4K8F4Eh5YSmV9P8xpp8hyIi0jeoxEJECoAS5L0IDinD6xpJ7mrKdygiIn2HSixEJM+UIO9FYEg5yS3NeGNUh4WIiOSC2ryJSAHIWYJsZrPM7G0zW25m13ZyzXlmttjMFpnZbzPGLzKzZemfi3IVc3BIGb65ERy8Qa3eRER6nKMaZBHJu1Au3sTMgsCdwExgLTDPzOa4++KMayYA3wCOd/etZjY4PT4A+CYwjdRH54L0vT2+cy4wpJzkpvRhIbuaCJQX9fRbioiISixEJM9ytYI8HVju7ivdPQo8CJzV5prPAXfuTnzdfWN6/DTgKXffkp57CpiVi6CDQ8pIrNhOIFZEsLpfLt5SRKRvU4mFiBSAXCXINcB7Gc/XpscyTQQmmtmLZvYPM5vVjXsxs8vMbL6Zza+rq8tK0IHBZdCUILm+AQuqXFtEJCe0gCwieVZIWV8ImADMAM4H7jaz/l292d3vcvdp7j6turo6KwFZJIRVFZOMRYmtyk7SLSIie6EFZBEpALlKkGuBkRnPR6THMq0F5rh7zN1XAe+QSpi7cm+PCQ4ph/5BokvX5eotRUT6LndMNcgikme5SpDnARPMbKyZRYDZwJw21zxCavUYMxtEquRiJfAEcKqZVZlZFXBqeiwnAkPK8C1N6oUsIpIryo9FJM9y0sXC3eNmdiWpxDYI3Ovui8zsRmC+u89hTyK8GEgAX3f3zQBmdhOpJBvgRnffkou4IbWCnNzQgNc340nHAvrkFhHpMSqxEJECkJMEGcDd5wJz24zdkPHYga+mf9reey9wb0/H2JHAkDKib68n7EPx+masX3E+whAR6TtUYiEieVZIm/QKUnBoOcn3dgKQrG/OczQiIr2c2ryJSAFQgrwPgZoKEsu2UfLhgwkNrcx3OCIivZ8WkEUkz5Qg70NweD+IO8kNDfkORUSk19MCsogUAiXI+xCsSZ2gF1tTR3Tx+3mORkSkl3NXDbKI5J0S5H0I1lQAkGxsIrZy4z6uFhGRD0z5sYjkWc66WByorKIIKw3jO2IkyxvzHY6ISO+mEgsRKQBaQd4HMyNQ049kXSPeHMebY/kOSURkv5nZLDN728yWm9m1HczfamZvpH/eMbNtGXMXmdmy9M9FPRhkj720iEhXaAW5C4I1FSTf20lwUgXJHU0Eq8P5DklEpNvMLAjcCcwE1gLzzGyOuy/efY27X51x/ZeAI9OPBwDfBKaRWuddkL53a1aD1C49ESkAWkHuguDwfsSXbYNwkGSTVpBF5IA1HVju7ivdPQo8CJy1l+vPBx5IPz4NeMrdt6ST4qeAWVmP0FENsojknRLkLgjW9CP+Zh3lFxxLeOSAfIcjIrK/aoD3Mp6vTY+1Y2ajgbHAM92518wuM7P5Zja/rq5u/6JUiYWI5JkS5C4I1lRANIFv0SY9EekzZgMPuXuiOze5+13uPs3dp1VXV3f/XVViISIFQAlyFwSHp3ohN7+2hsYX3slzNCIi+60WGJnxfER6rCOz2VNe0d17PxgtIItInilB7oJA+rCQ5NYGYqs341rhEJED0zxggpmNNbMIqSR4TtuLzGwSUAW8nDH8BHCqmVWZWRVwanosu/TxKiIFQF0sumD3YSG+KwaBON4cx4rVyUJEDizuHjezK0kltkHgXndfZGY3AvPdfXeyPBt40DNWA9x9i5ndRCrJBrjR3bf0QJCYapBFJM+UIHdBcFg5AL6pCQYHSW5vIFBcmeeoRES6z93nAnPbjN3Q5vm3Orn3XuDeHgtuN+XHIpJnKrHoAouECFSXkli7C4DktoY8RyQi0kupxEJECoAS5C4KjqoksWwrgQFlENDyhohIj1GJhYjkmUosuig4uj/xxXWUn/WhfIciItJ7aRO0iBQArSB3UXB0JYk129XBQkSkp2kBWUTyTAlyF4VGVeINMaJvrmXng6/gzTpyWkQk27QGISKFQAlyFwVH9wcguaUJb4yS0EY9EZHsc1cNsojknRLkLgqOTrV1883NgDpZiIj0GOXHIpJnSpC7KDgqlSAn1u6AUEAJsohIT1CJhYgUACXIXRQYWIqVhkms3kGgf6lKLEREeopKLEQkz9TmrYvMrKWTRcmYQyGeyHdIIiK9j3bpiUgBUILcDcFRlSRWb6No6oh8hyIi0js5qkEWkbxTiUU3BEf3J7F6OwCeSOJaRRYRyT6VWIhInilB7obQ6EqSmxqIb97Fzl+/RGzZhnyHJCLSu6jEQkQKgBLkbtjdySK5sQGLBEls3pXniEREeh8tIItIvilB7obg2CoAku9uJzCwXAmyiEi2aQFZRAqAEuRuCI1PJcjxFVsIDiwnua0BTyTzHJWISC+ik/REpAAoQe6GwJByrCxMfMVWggPLIekkt9bnOywR6UMs5XNm9oyZvZke+4iZnZfv2LJG+bGI5JkS5G4wM4Ljqkgs30JwSAVF08ZgJZF8hyUifcuNwCXAXcCo9Nha4Jq8RZRNKrEQkQKgPsjdFBo/gPjbmwiUFlE0dWS+wxGRvudi4Eh332RmP0+PrQLG5S+kLFOJhYjkmVaQuyk0vor4yq14MkmyMUp8/fZ8hyQifUsQ2L1DePd6a3nGmIiIfEBKkLspOH4ANCdIvr+T6FtraXhyIZ7URj0RyZm/AD82syJI1SQDNwGP5TWqbNICsojkmRLkbtrTySK9US/hJLc15DkqEelDrgaGAduBSlIrx6PpBTXIrkNCRKRAdDlBNrOTzWxs+vEwM/tvM/uVmQ3tufAKT2j8ACDV6i0wsByAxCZ9sykiPS+9WjwIOJfUBr1jgfHu/il335nX4LJhd4KsGmQRybPurCD/DEikH/8ICANJUjup98nMZpnZ22a23Myu7WD+YjOrM7M30j+XZswlMsbndCPmrAuOqoSgEV+xlUBFCYSDJDYd+P9fEpHC56kl1oVA0t03uvs8d1+f77iyTvmxiORZd7pY1Lj7GjMLAaeR+kovCry/rxvNLAjcCcwk1Y5onpnNcffFbS79nbtf2cFLNLr7Ed2ItcdYOEhwdH8SK7ak2r5V9yNRpwRZRHLmdWAisDTfgWSdKixEpEB0J0HeYWZDgEOBxe6+y8wipFaS92U6sNzdVwKY2YPAWUDbBPmAEDpoAPHlWwAonjYWgirlFpGc+RvwuJndB7xHRlrp7vfmKabsUomFiORZdxLkO4B5QAT4SnrseLq2ilFD6oN8t7XAMR1cd46ZfQR4B7ja3XffU2xm84E4cLO7P9L2RjO7DLgMYNSoUW2nsyo0cSAN//0e7p7aqCcikjvHk+p7fFKbcQcO7ARZm/REpEB0OUF291vM7E9Awt1XpIdrgUv3clt3PAY84O7NZvZ54L+Bj6bnRrt7rZmNA54xs4UZMeyO7y7S9dDTpk3r0U/Z0KRB+M4oyXU7CQ6vILpsA1YcIjxyYE++rYgI7n5yvmPoMbs/ubWALCJ51q2T9Nz9nd2PzexkUhtFnuvCrbVA5rFzI9Jjma+9OePpPcD3M+Zq0/9caWZ/A44EWiXIuRSaNAiA+NJNqQT5rbUEyoqUIItITphZFXAGqW/naoHH3H1rfqPKHlOJhYjkWXfavD1nZsenH18DPAj81syu68Lt84AJZjY2Xbc8G2jVjcLMhmU8PRNYkh6vymiIP4jU14t5rV0OpxPk2NupnD44uIJ43U718BSRHmdmHya1QHA5cBjweWBFevzAps9QESkQ3VlBPhT4R/rx54CTgZ3Ai8B393aju8fN7ErgCVLHpN7r7ovM7EZgvrvPAb5sZmeSqjPeAlycvn0y8EszS5JK6G/uoPtFTgWG98PKI8SXbgIgOLgfsXfWk9zWQLCqLJ+hiUjvdxvwBXd/cPeAmX0a+AlwdN6iyiYtIItInnUnQQ4AbmbjAdudpKa/6tsnd58LzG0zdkPG428A3+jgvpeAqd2Is8eZGaGDB7YkyKGh/QFIrNuuBFlEetpE4Pdtxh4CfpGHWLJLC8giUiC605/sBeCnwA+BPwGkk+VNPRBXwQtNGtSSIAf6FWPlRSS268hpEelxy0iVqWU6lzzuy8ganaQnIgWiOyvIFwNfA+qAH6THJgG3ZzmmA0Jo0iAa/2chyfoogbII5f9yFBYO5jssEen9vgL82cy+DKwGxgATgNPzGVRWKT8WkTzrTpu3zcB1bcb+N+sRHSB2b9SLv7OZyJHDlByLSE64+0vpb+8+CQwn1SJzrrtv2de9ZjaL1KJGELjH3W/u4JrzgG+RKnj4p7tfkB5PkDrmGmCNu5+ZhV9OayqxEJEC0eUE2czCwH8CnyH1ofw+8GvgO+4e7ZnwCldmq7fIkcPweILG594mNHIAkYlD8xydiPRWZlYDNLj7bzLGqsxsuLu/v5f7gsCdwExShzXNM7M5mZuezWwCqb0gx7v7VjMbnPESje5+RLZ/PZ0Em5O3ERHpTHdqkL8PnEKqtdDh6X9+FLilB+IqeKEJAyFoxBfXAWChIIkt9cTf2+cijojIB/EIqV7ymUaQ3huyF9OB5e6+Mr2o8SBwVptrPgfcubunsrtvzEK8XaZWmSJSKLqTIJ8LnOnuT7r72+7+JPAp4LyeCa2wWVGI0ISBxBZuaBkLDaskvn67PuRFpCdNdPeFmQPp55P2cV8N8F7G87XpsVavDUw0sxfN7B/pkozdis1sfnr8Xzp7EzO7LH3d/Lq6un3/ajLpJD0RKRDdSZA7+8jqsx9l4amDiS3cs8ASHFoJ0TjJLfV5jEpEerk6MzsocyD9fHMn13dHiNSGvxnA+cDdZtY/PTfa3acBFwC3peug23H3u9x9mrtPq66u3r8oVGIhInnWnQT5D8BjZnaamU1Oryw8kh7vk0JTh5BYuZXkrubU8+GpltDx2l5z4quIFJ57gYfN7HQzO8TMzgAeBu7Zx321wMiM5yPSY5nWAnPcPebuq4B3SCXMuHtt+p8rgb8BR37QX0g7+vZNRApEdxLk/ws8TWqTxwLgDuBZ4Os9ENcBITw1tX9ldx1yoDRCeFw1VhzOZ1gi0rvdDPyGVE/6eaT2h9yfHt+becAEMxtrZhFSvZTntLnmEVKrx5jZIFIlFyvTmwCLMsaPB3ruRFMtIItInu21i4WZfbTN0N/SP8aearETgGeyHdiBIDx1CACxhRuJTE/tmSk5aV9lgCIiH8hJwEPu/gMzG0Zqo/ShwGBgfWc3uXvczK4EniDV5u1ed19kZjcC8919TnruVDNbDCSAr7v7ZjM7DvilmSVJLazcnNn9Imu0gCwiBWJfbd7+q5PxzK0UDozLWkQHkODY/lhpuNVGPQCPJ/FYnEBJJE+RiUgv9jPgtPTjH6X/GQPuAvbam9jd5wJz24zdkPHYga+mfzKveQmY+oGi7g7VIItInu01QXb3sbkK5EBkgQChKdXEMzbquTu7/rSA0OB+Wk0WkZ5Q4+5rzCwEzAJGAVFSvekPbKpBFpEC0Z0aZOlAeOoQYm/tSZDNjNCQCuK1W/GkPuxFJOt2mNkQUqUWi9x9V3r8wN/8oDZvIlIglCB/QOHDhpDcWE9i3c6WsdCIAXhznETdzr3cKSKyX+4gteHuf0htmobUprmleYsoy0wlFiKSZ0qQP6DwUcMAiC7Y8+1mqKYKAkZ8TTbakoqI7OHut5A61fR4d38wPVwLXJq/qLJEJRYiUiCUIH9A4SOGQsCILVjXMmZFIULD+hN7t06n6olI1rn7O+6+os3zhXu754CiBWQRybN9dbGQfQiUFxGaNIjY/Nb7Y4qOHJ2niEREDlBaTxCRAqEEOQvCRw2j+emVrcaC1f3yFI2IyAFq9zduqkEWkTxTiUUWRKYNJ7luF4n3d7QaT2zaRdP8VSqzEBHpDuXHIpJnSpCzIHzUcACiGXXIAIktu4guXEtyc30+whIROaBoLUFECoUS5Cxo2ajXpg45NGogmBFbVZenyEREDkAqsRCRPFOCnAWBsgihyYNatXoDCBSHCY2oIrZyow4NERHZFy0hi0iBUIKcJeGjhhNbsK5dvXH4oCF4Q5TE+1vzFJmIyAFCJ+mJSIFQgpwlkWnDSa7fRbK29Ua90MgBBCpLSDbF8hSZiMgBRiUWIpJnSpCzJDK9BoDoP9a2GrdggLJPHUXkoCH5CEtE5MChEgsRKRBKkLMkfORQrCRE84vvtZszM9ydZEM0D5GJiBxgtIAsInmmBDlLLBIiPL2G6ItrOpxv/OtiGp5epJ7IIiKd0cejiBQIJchZFDl+FLHX1pGsb79SHBpRRXLzLhJ1O/MQmYjIAUQ1yCKSZ0qQs6jo+JGQcGKv1rabC48fDOEgsaXrOrhTRERUgywihUIJchZFPjwSgOYOyiwsHCJ80GBiq+pINqoWWUSknXR+rAVkEck3JchZFKgqITSlmmgHG/UAIpOGQdKJrdTJeiIinVKGLCJ5pgQ5yyInjCL60nt4ItluLti/jNKPTyUyeXgeIhMRKXAqsRCRAqEEOcuKjh+F72gmvmhjh/Ohof2xgFZHREQ6pY9IEckzJchZFjlxFADNz63u9Jrosg3Uz/2nWr6JiGTSR6KIFAglyFkWGlNFcHwVzU+v7PQaCxqJDTuIr9mcw8hERAqca5eeiBQGJcg9oOhj42h+dhUeT3Q4HxpTjfUrpvnNtVpFFhFpS/mxiOSZEuQeUHzKOHxnlOi89zuct4BRNHUEyU07ib+3JcfRiYgUJq0XiEihyFmCbGazzOxtM1tuZtd2MH+xmdWZ2Rvpn0sz5i4ys2Xpn4tyFfP+ipw8Boy9llmEJwwlUFFC84J3tYosIpJJJRYikmehXLyJmQWBO4GZwFpgnpnNcffFbS79nbtf2ebeAcA3gWmktnAsSN+7NQeh75fgoDLCRw6j+a8r4fqTOrzGAkbxcQdBwDD9z0BEREvIIlIwcrWCPB1Y7u4r3T0KPAic1cV7TwOecvct6aT4KWBWD8WZNUWnjCP60nsk6zs/NS80rD+hIZU5jEpEpIDtzo+1ZiAieZarBLkGyDxebm16rK1zzOxNM3vIzEZ2514zu8zM5pvZ/Lq6/J9UV3TKOIglif6983ZvAJ5M0vjycqKLa3MUmYhIgdO3aiKSZ4W0Se8xYIy7H0Zqlfi/u3Ozu9/l7tPcfVp1dXWPBNgdRSeMguIQTX9ZvtfrLBAgubOJptdWk2zofLVZRKTXU4mFiBSIXCXItcDIjOcj0mMt3H2zuzenn94DHNXVewuRlYQp+thYmh57e5+b8IqPGQeJJM3zV+UoOhGRAqYFZBHJs1wlyPOACWY21swiwGxgTuYFZjYs4+mZwJL04yeAU82sysyqgFPTYwWv5IyDSazaRnzx3ks+gpWlRA4dQWzFRuLrt+coOhGRAqMFZBEpEDlJkN09DlxJKrFdAvze3ReZ2Y1mdmb6si+b2SIz+yfwZeDi9L1bgJtIJdnzgBvTYwWv+PSJADQ99vY+ry06fCRWVkTTvJVq+yYifZNO0hORApGzGmR3n+vuE919vLt/Jz12g7vPST/+hrtPcffD3f1kd1+ace+97n5Q+udXuYr5gwrWVBA+ahhNc/adIFsoSMlJkyidMUlt30Skx+yrJ336mvPMbHF60eK3GeM56Umvj0ARybdC2qTXKxWfcTDRf6wlsXHXPq8NDakg0K8EdyfZFMtBdCLSl2T0pP84cAhwvpkd0uaaCcA3gOPdfQrwlfT47p70x5Bq3fnNdNlb9ujLMxEpEEqQe1jxGRPBoWnusi7f0/Tychrm/hOPJ3owMhHpg7rSk/5zwJ27D2Ny943p8dz1pNcSsojkmRLkHhY+chjBERU0/Wnpvi/efc/oQSS3N9I8/92eC0xE+qKu9JWfCEw0sxfN7B9mNqsb936wnvTafyEiBUIJcg8zM4r/9RCaHl9Ocltjl+4J1VQRmTyc6JL3idcW7InaItI7hYAJwAzgfOBuM+vf1Zuz0pNeC8gikmdKkHOgdPahEE3Q+EjXV5GLpo0h0L+UxueWktzZ1IPRiUgf0pW+8muBOe4ec/dVwDukEuae70mvBWQRKRBKkHMgPL2G4Jj+NP5uUZfvsVCQ0o8dghWFSTbqhD0RyYp99qQHHiG1eoyZDSJVcrGSHPSkd7V5E5ECoQQ5B8yMkk9PofnplSQ2N3T5vkBFCWWfOorQ4IoejE5E+oou9qR/AthsZouBZ4Gvp086zV1PeuXHIpJnoXwH0FeUfPpQdt3yIk1/XELZ547a9w1pFjDcneY31mABo+jwUT0YpYj0du4+F5jbZuyGjMcO/P/t3Xd8VFXawPHfc6dkJpX0QAiE3jSCoFhAsKCggK6rr7gWcEXBVVm2IaK4sjb0dSmW3VURxVcsi21tq+Iill0WBelNqdJDD0kmyZTz/jGTIQFCTTKT4fl+PsPknnPuveeEy+GZM+ee+9vQ6+B9pwJT665ydXZkpZQ6LjqCXE8cnXOwt02n9LUlJ7R/oMhD+fcb8K49zrvClVKqodEpFkqpCNMAuZ6ICO6bCqiYvR7fuuNbmUJEcJ/fBlt2Mp6vVuHdsKuOaqmUUhGky7wppeK7ilgAACAASURBVKKEBsj1KH5wZxAofXnhce8rdhvxl3TCSk/EM3uFLv+mlIo9lfGxDiArpSJMA+R6ZM9LIe7SVpS+tADjDxz3/uK0k3BpJ6zUBIw+ilopFat0ioVSKsI0QK5n8bd0wb+xiPJZ605of4lzkNC/M45WWQCYcg2UlVIxQqdYKKWihAbI9cx9ZTsk1UXpi9+f8DHECo6u+LbuZf+M73ROslIqtugAslIqwjRArmfichB/YwGed1fi3158UseyGsVjpcTj+WI5FSu31FINlVIqQnQAWSkVJTRAjoCEO8+GCj8lf5t3Usex3E4S+p6OvWkaZXPWUDZv3YEnUSmlVEMT6r9E5yArpSJMA+QIcLTLIK5fa0r++h2mwndSxxKHDfdFHXG0y6FiySZ8G3bWUi2VUipCND5WSkWYBsgRkvjrcwhsL8Hz92UnfSyxBNe5rXFf0hF78wwAjM9/0sdVSql6pV+AKaWihAbIERLXpyX2dukUT55bK9MiRARHXjoiQmB/GcVvfUfFyq065UIp1fDoFAulVIRpgBwhYlkkjOiOd94WKuZsrN2DOyystETK5qzGM3slpvzkpnEopVS90A/0SqkooQFyBMXffAbSyEXxk/+p1eNaLifxfToR1y0f34adFL83X5eCU0o1HDqArJSKMA2QI8hKjCPx7rMpe3cl3qXba/XYIkLc6XkkXNEZibPj26gBslIqyukAslIqSmiAHGGJI89BEp3sf+TrOjm+LTOJhIFdcHVvBYB/ZzHlSzed0KOulVKqLoXvmdA5yEqpCNMAOcKstHgS7jwLz5tL8a6qmyXaxLIQhw0A77pCyr9bR/E78/Gu26E38Smloo/Gx0qpCNMAOQok/vZcxGVn/8Nf1fm5XGe1JP7S0xCHhWf2Sko/WoSvsKjOz6uUUkeln9eVUlFCA+QoYMtKJOGus/FMX4x38bY6P589N5WEgWfiOr8NgeJy/Nv2AWACRkeUlVKRp1MslFIRpgFylEga3QNJcbHv3n/Vy/nEEpxtc0j8eTecHXMB8K7bQcm784PrJ+uDRpRS9U0/oCulooQGyFHCSosn6d4elH/8I+Wz19XbecVhQ+zBy8ByOcBho2zOaor//i1l368nUFpRb3VRSp3iKuNjHUBWSkWYBshRJPHu7li5SewbNRMTqP9VJuy5qST070x8vwJs2SlULNpI6ecn/yhspZQ6LjrFQikVYfZIV0AdIG4HKY9dwp6b36X0pYUk3Hpm/ddBBHtOCvacFAJFHgJlXgBMhY+SjxZhb5aOo0UGVmoCov+JKaVqk06xUEpFCR1BjjLuGwtwnp9H0ejPCewujWhdrGQ39qxkAEyZF4l3UrFkIyX/WEDJu/NDUzDKI1pHpVQM0s/eSqkI0wA5yogIjZ69gsBuD0Vjv4h0dcKsZDcJl51O4qDuuM5tjbidVCzaiKnwAeDfW4p/b6mugqGUOnHafSilooROsYhCjjNySPjVWZT85Tvih56Js0vjSFcpzHI5cbZvjLN9YwJlFVguJwDli37Ct3YHkhiHPTc1+GrcCHHqJaaUOkahD9g6fUspFWk6ghylkh+6ECsjnr23/gPjjc4l1yqDYwBXtxa4zm2NLS0R75odeGatoOTDheF8/+7iqG2HUirKaHyslIowHd6LUlYjN43+1p/dV7/J/vHfkDy2V6SrdERWQlx4ZNn4A/h37A9PvzDGUPLPJeD1Y6UnYMtIwpaRhD0nBSvJFeGaK6Wihk6xUEpFCR1BjmLun3XA/YvT2f+nL6lYuDXS1TlmYrOw56TgaJYeTDAQ36sdztObIg4b3jWFlH3zAxWrgm0yPj9l89bhXb+TQHG5zmNW6lSnUyyUUhGmI8hRLuWpfpT/ay17h7xH5re3Ncg5vWIJ9qZp2JumAcER5cA+T/gBJYF9HiqWbYZAaP5hnB0rNYG4Ls2x56RgvH6Mz4+4HDo3UalYph+OlVJRouFFW6cYW3o8jZ4fwO4r32DfPZ/TaGLfSFfppIkItkbx4W1beiJJN55HYHcJ/h378e8pIbCnJDyK5Nu8B88XK8Bpx5bixmoUj5USj6N1FpbbiTFGA2elYoDRJ+kppaJEvQXIItIXmAzYgCnGmPE1lPs58BZwljFmnojkAyuAVaEi/zXGDK/7GkcP98D2JIzoTsmk/xLXsxnuqztGukq1TmwWtswkbJlJh+TZ0hOI696SwN5SAvs8+Dbtxvy4HXuzdHBDxYotVCzehJXkwkqMQ5JcWIkuHC0zEbtNA2ilGhr996qUirB6CZBFxAY8C/QBNgHficj7xpjlB5VLAn4NzD3oEGuMMZ3ro67RKuV/+1Dx303sueUfOM7Iwd4qLdJVqjdWkpu4jrnV0ky5Dxw2AGwp8dhzUwkUl+ErLMKs2wEGHC0zASj/bh3e1duReCfidmLFO5H4OOLObI6IENhfBhjE7UTstvpunlKqkk6xUEpFifoaQT4bWG2MWQsgIm8AVwLLDyr3EPA48Id6qleDIU47aW9eQ+GZz7H72r+T+Z9bEZcj0tWKGIk7cOlWrrtcyQQCmNKKcLBry0rC+PyY0goCngp8e0vBGFxd8wEom7cO3/qdwZ2dNiy3EyslnviLgyP13rWFmHJfcA50nAOJsyMuB1ZCXP00VqlTjQ4gK6UirL4C5FxgY5XtTUD3qgVE5EwgzxjzkYgcHCC3EJEFQBFwvzHm64NPICK3A7cDNGvWrDbrHjXs+amkvvIzdg94nT23f0DqtJ/p1IHDEMtCEg8sH+fIz8SRn1mtTNWVMpyn5WJvmhoOoI3HizgOjCRXLN+Cf8f+avtbGYkkDugCQMknSwgUlyEOG+K0Iw4btswk4s4IXocVP26DgAke0xHMt+KdWMnuYF38AbBE/y6V0gFkpVSUiIqb9ETEAiYAQw6TvRVoZozZJSJdgfdEpJMxpqhqIWPM88DzAN26dYvZbtbdvx1Jf7qQ/Q98gb1tOsn3R/f6yNGqajBqz0yGzOQay8Zffgam3IvxeIPvFT7EdmCFRFt2MpbbEVxto8JHoLi82uh++fz1GI+32jHt+RnEX9gBgP1v/Be8AXBYiM2G2C3srbJwdWmOMQbPrBVgs4KrftiDZWyNU3A0TcMEAnh/2B5Kt4LlbBZWshsryYUJGAL7PQfyLAGrys/qlHK0e0FEZAjwv8DmUNIzxpgpoTw/sCSU/pMxZmAdVrTODq2UUseivgLkzUBele2mHOiAAZKA04DZocAlB3hfRAYaY+YB5QDGmPkisgZoC8yrj4pHo6T7L8D3wy72j/0Ce5t04q87LdJVimliCeJ2gtt52HxXl+ZH3D/x6m7B4NnrB68f4/UhzgMBdFxBHqbCDz4/xhfA+PxY8aFzGQgUl0Eo3fgC4A/gFHA0TQOvn7I5qw85Z1yX5sR1boYpraDknfmH5p/dkrhOufj3llLy4cJQ4CzBwMQSXN1a4GiRiX9PCZ5vfkAsK5hvCWIJztPzsOek4N9dQvmSjcEPHJX7Czg7NMGWmoB/Twne1YXBr8xDZUTA0ToHKzEO/94SfJv3goQ+tIT2tzfPwHI58O8rxb+zOBQvSfg49txUxGEjUOQhUOQJ7xf8w2DLSUEsK5i/vyz0F3ngGLaclOD88yIPAU/FgWMTWmUldLNooLgsON+96v5W9VVYGopjvRcEeNMYc9dhDuGp83tBdA6yUipK1FeA/B3QRkRaEAyMBwG/qMw0xuwDMiq3RWQ28PvQKhaZwG5jjF9EWgJtgLX1VO+oJCKkThmIf/1e9gx+F1t2AnG9W0S6WqoG4rQfcf3quNPzaswTS0i88syaD+60k3jd2cEA2h8Mno0/EJ4fLXF23Be0O5AXMBAIYM9ODtfN2SY7mG5McC3qQPCGxWABQeIcofQAeAMETOhnwHh9weknxgS/Hg8dx5GfCakQKCqjYsWWUL4Jf4Vua5waDJB3FFP+7aH/nBMyk8HlwL95L2Vz1xySn3jNWcGHzqzfSfn89YfmX38O4rKo+HE7FYs3HpKfdPP5YBPKl2/Gu+Kgh/CIkDykBwDlCzYEA/yDfufJN5xb099INDvWe0EiR5d5U0pFiXoJkI0xPhG5C/iU4Fd7U40xy0TkT8A8Y8z7R9j9AuBPIuIFAsBwY8zuuq91dJM4O2nvDWLnBS+xa8DrZHwxGGe33KPvqGKKiCDxNd8sKA4bjlZZNeZb8U5c3VvVmG9rFE/CpTV/Q2HPTiHpmrNqzHc0T8dx8/nhbVMZJIcCIEfLTBzN0kPpoTxjEHdwhN3ROgtbbipQNR8kNMLuaJ2FLSclvF/lwcUZnEPubJeDvWnoBk4T+sMQHO0GnO2b4MirfOKjOWQKrLNjLvZmGQf248C+DdBR7wUJ+bmIXAD8APzGGFO5j0tE5gE+YLwx5r3DnaRW7gfRKRZKqQirtznIxpiPgY8PSnughrK9q/z8NvB2nVaugbKlx5Px2U3s6DGVXX1fJeOrW3B0rDkYUirSRKTa6GB4bnRN5Z12bEcYfbfi47CO8AHBSgyuiV0TW6N4OMJ0CVt6Irb0xBrzY9AHwOvGmHIRGQZMAy4K5TU3xmwOfZM3S0SWGGMOGd4/qftBdIqFUipKWEcvoqKZLTeZjM9vBoeNnRdNw7us8Og7KaVORUe7FwRjzC5jTHlocwrQtUre5tD7WmA20KWuKqoDyEqpSIuKVSzUybG3SiNj1mB2XjyNnb1fJn3mTTg7N450tZRS0eWI94IAiEhjY0zlpOyBBJ9iioikAqWhkeUM4HzgiVqvoQ4gx6SioiIKCwvxer1HL6zUSXA4HGRlZZGcXPPKVMdKA+QY4eiQSeZXt7DzomnsvHAaGZ/eiPPsppGullIqShzjvSAjRGQgwXnGuzmw9GYH4DkRCRD85nH8YVa/qI1KBt91CDlmFBUVsX37dnJzc3G73breu6ozxhg8Hg+bNwe/GDvZIFkD5Bhib51Oxle3sPPiV9h58SukvXkNrsvbRrpaSqkocbR7QYwx9wL3Hma//wCn13kFK2kMFTMKCwvJzc0lPr7hLY2oGhYRIT4+ntzcXLZs2XLSAbLOQY4x9vxUMr++BXubNHYNeJ3iZ7+NdJWUUurY6BSLmOP1enG73ZGuhjqFuN3uWpnOowFyDLI1SSbjq1twXdGGfXd9zN5f/zO4Dq5SSjUE+jV8TNFpFao+1db1pgFyjLIS40h7dxAJvzmHkqfmsqv/a/h3lUa6WkopVTNd5k0pFSU0QI5hYrNoNKEvjf7Wn/JZ69jR5W9U/PfQp4oppVQ0MPokPXWKWLlyJSLCvHnzIl0VVQMNkE8BCcO6kfmfW8FusaPnSxRPnBN8cplSSkUj/UpeRZiIHPGVn59/Usdv06YNW7dupXPnzrVTYVXrNEA+RTi7NiHr+2G4+rdl328/ZdcV0/FvKYp0tZRS6gD94K6ixNatW8Ovt98OPsz3+++/D6d99913h92voqLimI5vs9nIycnBbo/NxcSO9fcQzTRAPoVYjdykvXMdKU/3o2L2erZ3+gulry7S0WSlVHTRAWQVYTk5OeFXWloaAJmZmeG0zMzMcLlx48Zx++23k5aWRp8+fQB48sknKSgoICEhgSZNmnDjjTdSWHjgSbcHT7Go3H7nnXfo168f8fHxtG7dmtdee+2I9dyxYwfXX389eXl5uN1u2rdvz9NPP31IuVdffZXOnTvjcrnIyMigf//+FBcXA8H1gydNmkT79u2Ji4sjOzubX/ziwDOEcnJyePLJJ6sd78Ybb6Rv377h7XPOOYc77riD0aNHk5OTQ9u2wSVmp02bxllnnUVycjKZmZkMHDiQNWuqP6F+69at3HzzzWRlZeFyuWjfvj2vvvoqfr+fpk2bMmHChGrl9+7dS3x8PDNmzDji7+ZkaYB8ihEREu/qTtaiO3B0zGTPTe+y++o38W/W0WSlVITpZ3XVAP35z38mPz+fuXPn8txzzwHB/2snTZrE0qVLmTFjBj/88AM33XTTUY91zz33cNttt7F48WKuuuoqhgwZwvr162ss7/F4OPPMM3n//fdZvnw5o0ePZtSoUbz++uvhMn/961/55S9/yaBBg1iwYAGzZs3ioosuwu/3AzB69GgeeOABRo4cydKlS/noo484/fTjX/b81VdfpbS0lC+++IIPP/wQCI4kjxs3jgULFvDJJ5/g9XoZOHAgPp8PgOLiYnr27MnKlSt54403WL58ORMnTiQuLg6bzcatt97KlClTqp1n+vTpJCUlcdVVVx13HY9HbI7tq6Oytwk+VKR44hyK7p/F9vbPkPTHXiT++hzEYYt09ZRSpzKdgxzT9o78J96F2+r9vI7OOTSa1K/Wj9uzZ0/GjBlTLe13v/td+OcWLVowefJkzjvvPHbt2kV6enqNx/rNb37D1VdfDcCjjz7K008/zZdfflnjnOdmzZrxhz/8odq55syZw2uvvcb111+PMYYHH3yQESNGMHr06HC5goICAPbs2cPEiROZMGECw4cPD+d369bt2H8BIc2bN2fy5MnVllm77bbbqpWZOnUqTZo0YdGiRXTt2pVp06axbds2/v3vf5OdnQ1Ay5Ytw+WHDh3KI488wjfffEOPHj0AmDJlCkOGDMHhcBx3HY+HjiCfwsRmkfT788lefifOXs0p+sNMCjv/jfIv1kW6akqpU5FO91IN0Nlnn31I2ueff06fPn3Iy8sjKSmJSy65BIANGzYc8VhVb9pzOp1kZGSwffv2Gsv7fD4efvhhCgoKSE9PJzExkZdeeil8no0bN1JYWMill1562P2XLFmC1+utMf94nHXWWYesQTx//nyuvPJK8vPzSUpKok2bNsCB38P8+fMpKCgIB8cHy8vLo1+/frzwwgsAzJs3j0WLFjF06NCTru/R6Aiywt4yjYwPb8DzwSr2jfgnOy+ahmtAW5LHX4KjY1akq6eUOlXoMm+nhLoYxY2khISEaturV6+mf//+DB06lHHjxpGens6aNWu44oorjnrzmtPprLYtIgQCNT/o67HHHmPixIlMnDiRgoICkpKSGD9+PN98882JN+gglmUdcq/S4Z5Ud/DvYd++ffTp04c+ffowbdo0srOzqaio4Iwzzjium/iGDx/Otddey+TJk5kyZQq9e/cOB9p1SUeQVZh7QDuyl99J8mMXU/7lBgpP/yt7bntf5ycrpeqXTrFQDdjcuXPxer1MmjSJ8847j3bt2rFtW91MKfnqq68YMGAAgwcPpkuXLrRu3ZoffvghnJ+Xl0dWVhafffbZYfc//fTTcTgcNeYDZGVlsWXLlvC2MYaFCxcetW5Lly5lz549jB8/nl69etG+fXt27txZrUzXrl1ZvHjxEUfJ+/XrR2ZmJs8//zyvv/76IdM26ooGyKoacTtIGt2T7DUjSBjRndJpC9nWcjJ77/gQ3/o9ka6eUiqW6RQLFQPatm1LIBBg4sSJrFu3jrfffpvHHnusTs7Vrl07Pv/8c77++mtWrVrFqFGjWLRoUThfRBg7dixPPfUU48ePZ+XKlSxdupTJkyezb98+UlNTGTFiBGPGjOG5557jxx9/ZOHChTz++OPhY1xyySW8+uqrzJo1i5UrV3LXXXcdU8DfokULHA4HTz31FGvXruWzzz6rNl8aCK9eMWDAAGbNmsW6deuYOXMmb731VriMZVkMHTqUsWPH4nA4wnO065oGyOqwbBkJNJrYl+xVdxN/S2dKpi5ge+un2DPkXbyrdh79AEopdYJ0AFk1ZGeddRYTJkxg8uTJdOzYkaeffpqJEyfWybnGjRtH9+7dufzyyzn//POpqKiodrMdwF133cXzzz/P9OnTKSgooHfv3nz++efYbMEb8p944gkeeOABnnzySTp16kTfvn1ZsmRJeP/777+fSy65hKuvvprevXvTpEkTBgwYcNS6NWnShGnTpvH+++/TsWNHxowZc8jvISkpia+//prWrVtz7bXX0qFDB0aMGEF5eXm1ckOHDsXn8zF48GDi4uJO9Nd1XCQW18Dt1q2b0cc31i7/5iL2P/kfSp+bhynz4bqyPYkjuuPsnX/IpHyl1OGJyHxjzPHfHt5AHW9fXPbPH9l1+XQy59yK85y8OqyZqi8rVqygQ4cOka6GauC+//57unbtyooVK2jfvv1Ryx/pujvWflhHkNUxseUmB0eU148k8d6eVHy9gZ0XTaOw4K+UPDePQEnDf2qOUirCKgds9EO3UgooKytj06ZN3HvvvfTr1++YguPaogGyOi62rERSHrmYnI2/pdHUKxGHxd7hH7Kt6QT23vURFfM265P5lFInR+NjpRTw8ssv07x5c7Zt28YzzzxTr+fWAFmdEHE7SLilC5nzh5HxzS9x9WtNyYsL2HHWCxQW/JX9f/4P/u3Fka6mUqoh0c/WSqkqhg8fjt/vZ9GiRdUeIFIfdB1kdVJEhLjzmxF3fjMCez143lxGycsLKfr9ZxTdM5O4S1vhvrYT7ivbYaXFR7q6SqmGQKdYKKUiTANkVWusRm4ShnUjYVg3vCt2UDptIZ43l7H3l/9gr90i7qIWuK/piOuq9tgyE45+QKXUKUWnZymlooUGyKpOODpkkjK+D8mPXYL3+6143lqOZ8Yy9t7+AQz/EGev5rj6tcF1WSvsp2frShhKKX2SnlIqamiArOqUiODs2gRn1yYkP3oxvsXbg8HyeyspGjWTolEzsXISievTEtdlrYnr0xJbVmKkq62UiiT9wKyUijANkFW9EREcZ+TgOCOH5Icuwr+5iLKZayj/dA3lH/+I5/8WA+DokkPcpa1wXdoKxzlNseKdRzmyUiom6BQLpVSU0ABZRYwtN5mEIV1IGNIFEwjg/X4r5Z+toezTNRT/eQ7Fj/8bbIKjcw7Oc/NwnpeH89ym2Jo30ikZSsUy/eetlIowDZBVVBDLwtktF2e3XJLGXEBgfzkVX22g/D8bqZizkdKpCyh55lsArJzEcLDsPDcPZ9fGiMsR4RYopU6aDiArpaKEBsgqKllJcbiuaIvrirYAGJ8f75JCKkIBc8V/NlL2zopgYYeF47QsHF0a4+icg6NLDo6CbKxkVwRboJQ6bvokPaVUlNAAWTUIYrfh7NIYZ5fGcOfZAPi37afiv5uomLMJ74KtlL2/itKpC8L72FqnBadndM7BfloWjk6Z2FqkIjZ9Po5SSqkjGzJkCNOmTQPAbreTkpJC+/btGThwIHfeeScJCbpcaSzTAFk1WLacJNxXdcB9VQcguIZqYMt+KhZsxbtwG94F2/B+v5Wyt5aH9xG3HXuHTOxt07G3ScPeJvhua5OOLV0fZKJUROkybyrK9OzZk7///e8EAgF27drFN998w2OPPcaLL77IV199RXZ2dqSrGBEVFRU4nbF9A70OpamYISLYcpNx929H8v29SH/7OnLW/JrGRfeS+d+hNHpxIPHDu2FlxlMxdxP7H/maPTe/y45zX2RbxhNsSRtP4TkvsPumdyj602xKX19CxbzNBPaVRbppSp1S9CZcFS2cTic5OTk0adKE008/nTvuuIM5c+awY8cORo8eXa3s008/Tfv27XG5XLRp04ZHHnkEn88HwH333Ue7du0OOf4dd9xBjx49ajz/zJkz6d27N2lpaaSkpNCrVy++/fbbamWKi4sZOXIkeXl5xMXFkZ+fz6OPPhrOLyws5JZbbiE7OxuXy0W7du2YOnUqALNnz0ZE2LRpU7Vj2u12Xn75ZQDWr1+PiDB9+nQuv/xyEhISGDt2LMYYbrvtNlq1aoXb7aZly5aMGTOG8vLyasf6/PPP6dmzJ/Hx8eE2rFmzhtmzZ2Oz2di4cWO18q+88gopKSmUlJTU+HupDzqCrGKelRSHs3tTnN2bVks35T586/bg+3E3vh934Q+9V3y5Hs+ri6sfIyMeW34jbPmNsDdPCf7cvBG2vGRsTZOx0uP1P3WlTpYu83bKKPnn4kPSHPkZODs0wfj8lM5cdmh+62ycbbIJlHnxfLHikHxnu8Y4WmYSKC7H8/WqQ/IT+hXUSt1zc3O54YYbeOWVV3jxxRexLIsHH3yQl156iUmTJtG5c2dWrFjB8OHDKSsr46GHHmLw4ME8+uijzJ07l+7duwNQXl7Om2++yfjx42s8V3FxMb/61a8444wz8Pl8TJw4kb59+/Ljjz+Snp6OMYb+/fvz008/8fTTT1NQUMCmTZtYtSrYfo/HQ69evXC73UyfPp2WLVuyevVqdu/efdztvueee3j88cd59tlngeC3tllZWbz22mtkZ2ezePFihg0bhsPhYNy4cUAwOL7sssu4++67eeaZZ4iLi+Pf//43Xq+X3r1706ZNG6ZOncof//jH8HleeOEFfvGLX0R8CosGyOqUJXF2HO0zcbTPPCTPeLz41uwOB8++1bvxb9iHb/F2yj5YBeX+6ju47Nhyk7DlpWBrmnzg1SQJKzsBW04iVnYiVkJsfyWlVK3Qz5oqynXq1ImioiJ27txJYmIiTzzxBO+88w59+/YFoEWLFjz88MOMGDGChx56iLZt29K9e3deeeWVcID8wQcf4PF4+J//+Z8az/Ozn/2s2vbzzz/P22+/zSeffMINN9zArFmz+PLLL/nuu+/o1q0bAC1btuSCCy4A4LXXXmPdunWsXr2apk2bhvNPxLBhw7jhhhuqpT3yyCPhn/Pz81mzZg1/+ctfwgHyuHHj6NevH5MmTQqXa9++ffjn22+/ncmTJzN27Fgsy2LlypV88803PPXUUydUx9qkAbJShyFuB47TsnGcduj8MhMIECgswb9hH/5NRYe8Kr75Cf/mIvAGDj1uggMrOxFbdkIwYM5OwFbDuyTF6ai0OrXoAPIp40ijuWK3HTHfcjmOnJ8YV2ujxTUxoW87RIRly5bh8Xj4+c9/Xq3P9vv9lJWVsWPHDjIzMxk8eDBjx45l0qRJOBwOXnnlFQYOHEijRo1qPM+6det44IEHmDNnDoWFhQQCAUpLcLsK4wAAEOJJREFUS9mwYQMA8+fPJzU1NRwcH2z+/Pl07NgxHByfjLPPPvuQtBdeeIEpU6awfv16SkpK8Pl8BAIH/u+bP3/+EUfIBw8ezH333cenn35Kv379mDJlCl27dqVLly4nXd+TpQGyUsdJLAtbThK2nCTofvgyJhAgsKMU/+YiAttL8G8vrvYe2F6Mb/VuAv/+icDO0sMHBi57MJDOiMdKdWOlBV+S6gr+XJkW2pbQtsQ7NLBWDZMu86YaiGXLlpGSkkJ6ejpr164FYMaMGbRt2/aQsmlpaQAMGjSIkSNH8tFHH3H++efzySef8N577x3xPP379ycjI4Nnn32WvLw8nE4nPXr0oKKiolbaYVnBW9FMlelNfr+/WpBb6eApDzNmzODOO+9k/Pjx9OrVi+TkZGbMmMF99913zOdPT0/nmmuu4YUXXuDiiy/mlVde4eGHHz7B1tSueguQRaQvMBmwAVOMMYf9SCEiPwfeAs4yxswLpd0L3Ar4gRHGmE/rp9ZKnRixLGzZidiyE49a1vj8BHaWHjaQ9m8rJrCrlMCeMvw/7SOwx0Ngtwf8Rxhqc1jVAuhqAXVyHJLkRJLisA56lyQnVuhdEp2IpffwqgjR+FhFsc2bNzN9+nSuvvpqLMuiU6dOuFwu1q5dy+WXX17jfqmpqQwYMID/+7//46effiItLY3LLrusxvK7du1i+fLlfPzxx+FymzZtorCwMFyma9eu7Nmzh3nz5h12FLlr165MnTqVTZs2HXYUOSsrC4AtW7aQl5cHwMKFC6sFzDX56quv6NKlC7/97W/DaevXrz/k/J999hkjRoyo8TjDhg3jwgsv5LnnnsPj8XD99dcf9dz1oV4CZBGxAc8CfYBNwHci8r4xZvlB5ZKAXwNzq6R1BAYBnYAmwOci0tYYc9AkUKUaJrHbwiPSx/I8QGMMprgiHCybPWUEdnvC24HQtqnc3lqMb9kOAns8mKLyY/4aWxIchwTO4QC6amCd6ERc9kNeuOyI+9D0cJ7LrkF4BBxtsEJEhgD/C2wOJT1jjJkSyhsM3B9Kf9gYM61WK6dTLFSUqaioYNu2bYcs85aVlcVjjz0GQGJiImPGjGHMmDGICJdccgk+n48lS5awYMECHn/88fDxbr75Zq699lpWrFjBDTfcgM1mq/HcqampZGZm8sILL9CqVSt27drFqFGjcLvd4TIXXXQRPXv25LrrrmPChAkUFBSwZcsWVqxYwdChQ7n++ut54oknGDhwIE888QStWrVi7dq17Ny5k+uuu47WrVvTvHlzHnzwQSZOnMjOnTvD7Tiadu3a8eKLL/KPf/yD0047jQ8//JB33nmnWpmxY8fSr18/Ro4cyS9/+Uvi4uKYM2cO5557bnhVjx49etCuXTt+//vfc/PNN5OUlHRcf0d1pb5GkM8GVhtj1gKIyBvAlcDyg8o9BDwO/KFK2pXAG8aYcmCdiKwOHW9OnddaqSgkIqEANQ6a1Tx37XCMMZhSL2Z/OWZ/BYGD3s3+cgKV70WHpvk3FVUrazy+k2uM01Zz8Fz5ch8hL1zGUXOeyw6HCdRx2E65qSjHOlgBvGmMueugfdOAPwLdCIay80P77qmDitb6IZU6EV9//TWNGzfGZrORkpJChw4duOuuuw55UMjYsWNp3LgxzzzzDL/73e9wu920bduWIUOGVDtev379SElJYcWKFbz++utHPLdlWcyYMYMRI0ZQUFBA8+bNefTRR7nnnnvCZUSEjz76iDFjxjB8+HB27dpFbm4uw4YNAyA+Pp4vv/ySUaNGMWjQIIqLi8nPzw8vUWe323nzzTf51a9+RZcuXWjbti3PPPMMF1544VF/N8OGDWPJkiXccsst+Hw++vfvz4MPPsjdd98dLnPppZfy8ccf8+CDD/Lcc8/hdDo588wzwzcRVrrtttsYOXIkt99++1HPW1/kWIbRT/okItcAfY0xQ0PbNwHdq3bAInImcJ8x5uciMhv4vTFmnog8A/zXGPNqqNyLwD+NMW8ddI7bgdsBmjVr1rVyArtSqu4Ynz8YcJf7MR4vpswHZT7MYV6U+TCeI+SV+cLHOGxeuEwoveIkv0QSqgfdbkfwPc4WDNwdNnBY1d7FYYHDhpWVQKOJfY//lCLzjTGHv5umHojIucCDxpjLQtv3AhhjHqtSZgjQ7TAB8vVAb2PMsND2c8BsY0yN/8t369bNzJs375jrV/r3pey57i2ylv4KR6esY2+YilorVqygQ4cOka6GinKjRo1i5syZLFiw4OiFj8GRrrtj7Yej4iY9EbGACcCQEz2GMeZ54HkIdsq1UzOl1JGI3YYk1/wVYV0ygQCU+w8bcBuPt8ZA/WjBuvF4wRvAeP3gDRAorb5tvH5sWQ32EbO5QNVV+Tdx+FtNfy4iFwA/AL8xxmysYd/cg3c8aLDiuCpnJTix5TdCnJG5ppRS9Wvfvn388MMPPP/881GxtFtV9RUgbwbyqmw35cD8NoAk4DRgdugrzxzgfREZeAz7KqVOQWJZ4LaC0ytUbfoAeN0YUy4iw4BpwEXHuvPJDFa4rmhLzhWHrgKglIpNV155JXPnzmXQoEHceOONka5ONfUVIH8HtBGRFgSD20HALyozjTH7gIzK7YOmWHiA10RkAsGb9NoA1Z+zqJRS6lgcdcDBGLOryuYU4Ikq+/Y+aN/ZtV5DpdQpY/bs2ZGuQo3q5RZyY4wPuAv4FFgB/N0Ys0xE/hQaJT7SvsuAvxO8oe8T4E5dwUIppU5IeLBCRJwEByver1pARBpX2RxIsM+GYP99qYikikgqcGkoTSmlYk69zUE2xnwMfHxQ2gM1lO190PYjwCOHK6uUUurYGGN8IlI5WGEDplYOVgDzjDHvAyNCAxc+YDehe0OMMbtF5CGCQTbAn4wxu+u9EarBMcaccivGqMiprcUnouImPaWUUvXjaIMVxph7gXtr2HcqMLVOK6hiisPhwOPxEB8fH+mqqFOEx+PB4Tj5e1N0lX6llFJK1YmsrCw2b95MaWlprY3sKXU4xhhKS0vZvHlz+AmBJ0NHkJVSSilVJ5KTk4Hgo4y9Xm+Ea6NincPhIDs7O3zdnQwNkJVSSilVZ5KTk2slYFGqPukUC6WUUkopparQAFkppZRSSqkqNEBWSimllFKqCg2QlVJKKaWUqkIDZKWUUkoppaqQWFyXUER2ABtOYNcMYGctVyfSYrFNoO1qSGKxTXBi7WpujMmsi8pEoxPsi/V6aVhisV2x2CaIzXbVWT8ckwHyiRKRecaYbpGuR22KxTaBtqshicU2Qey2K9Ji9feq7Wo4YrFNEJvtqss26RQLpZRSSimlqtAAWSmllFJKqSo0QK7u+UhXoA7EYptA29WQxGKbIHbbFWmx+nvVdjUcsdgmiM121VmbdA6yUkoppZRSVegIslJKKaWUUlVogKyUUkoppVQVGiADItJXRFaJyGoRGR3p+hwPEZkqIoUisrRKWpqIzBSRH0PvqaF0EZGnQu1cLCJnRq7mNRORPBH5QkSWi8gyEfl1KL2ht8slIt+KyKJQu8aF0luIyNxQ/d8UEWcoPS60vTqUnx/J+h+JiNhEZIGIfBjajoU2rReRJSKyUETmhdIa9DUY7bQvji6x2BfHcj8M2hfX5jV4ygfIImIDngX6AR2B60WkY2RrdVxeBvoelDYa+Jcxpg3wr9A2BNvYJvS6HfhrPdXxePmA3xljOgLnAHeG/k4aervKgYuMMWcAnYG+InIO8Dgw0RjTGtgD3BoqfyuwJ5Q+MVQuWv0aWFFlOxbaBHChMaZzlXU2G/o1GLW0L45KsdgXx3I/DNoX1941aIw5pV/AucCnVbbvBe6NdL2Osw35wNIq26uAxqGfGwOrQj8/B1x/uHLR/AL+AfSJpXYB8cD3QHeCTwGyh9LD1yPwKXBu6Gd7qJxEuu6HaUvTUAd1EfAhIA29TaH6rQcyDkqLmWsw2l7aF0f/9RJrfXEs9cOh+mlfXIvX4Ck/ggzkAhurbG8KpTVk2caYraGftwHZoZ8bXFtDX/t0AeYSA+0Kff21ECgEZgJrgL3GGF+oSNW6h9sVyt8HpNdvjY/JJGAUEAhtp9Pw2wRggM9EZL6I3B5Ka/DXYBSLxd9hzFwvsdQXx2g/DNoXQy1eg/YT2Uk1HMYYIyINci0/EUkE3gZGGmOKRCSc11DbZYzxA51FpBHwLtA+wlU6KSLSHyg0xswXkd6Rrk8t62GM2SwiWcBMEVlZNbOhXoMqMhry9RJrfXGs9cOgfXFdXIM6ggybgbwq201DaQ3ZdhFpDBB6LwylN5i2ioiDYIc83RjzTii5wberkjFmL/AFwa+8GolI5YfVqnUPtyuUnwLsqueqHs35wEARWQ+8QfCrvck07DYBYIzZHHovJPif6NnE0DUYhWLxd9jgr5dY7otjqB8G7Ytr/RrUABm+A9qE7vR0AoOA9yNcp5P1PjA49PNggvPGKtNvDt3leQ6wr8pXFFFDgsMTLwIrjDETqmQ19HZlhkYsEBE3wbl8Kwh20NeEih3crsr2XgPMMqFJVdHCGHOvMaapMSaf4L+dWcaYG2jAbQIQkQQRSar8GbgUWEoDvwajnPbFUSYW++JY7IdB+2Lq4hqM9OTraHgBlwM/EJyHdF+k63OcdX8d2Ap4Cc61uZXgPKJ/AT8CnwNpobJC8C7xNcASoFuk619Dm3oQnHO0GFgYel0eA+0qABaE2rUUeCCU3hL4FlgNzADiQumu0PbqUH7LSLfhKO3rDXwYC20K1X9R6LWssl9o6NdgtL+0L46uVyz2xbHeD4fqrH1xLVyD+qhppZRSSimlqtApFkoppZRSSlWhAbJSSimllFJVaICslFJKKaVUFRogK6WUUkopVYUGyEoppZRSSlWhAbJStURE8kXEVFmUXSmlVD3TvljVBg2QlVJKKaWUqkIDZKWUUkopparQAFnFNBFpIiJvi8gOEVknIiNC6Q+KyFsi8qaI7BeR70XkjCr7dRCR2SKyV0SWicjAKnluEfmziGwQkX0i8k3okaWVbhCRn0Rkp4jcV4/NVUqpqKR9sWpoNEBWMUtELOADgo+ozAUuBkaKyGWhIlcSfNRmGvAa8J6IOETEEdrvMyALuBuYLiLtQvs9CXQFzgvtOwoIVDl1D6Bd6HwPiEiHOmukUkpFOe2LVUOkj5pWMUtEugMzjDHNqqTdC7QFNgB9jTHnhNItYDPwP6GiM4AmxphAKP91YBXwJ6AEOMcYs+ig8+UD64A8Y8ymUNq3wARjzBt11EyllIpq2herhkjv8FSxrDnQRET2VkmzAV8T7JQ3ViYaYwIisgloEkraWNkhh2wgOPKRAbiANUc477YqP5cCiSfcAqWUavi0L1YNjk6xULFsI7DOGNOoyivJGHN5KD+vsmBo1KIpsCX0ygulVWpGcFRjJ1AGtKqXFiilVMOnfbFqcDRAVrHsW2C/iNwTupnDJiKnichZofyuInJ1aK3MkUA58F9gLsHRhlGheXC9gQHAG6GRjKnAhNBNJzYROVdE4uq9dUop1TBoX6waHA2QVcwyxviB/kBngvPRdgJTgJRQkX8A1wF7gJuAq40xXmNMBcFOuF9on78ANxtjVob2+z2wBPgO2A08jv5bUkqpw9K+WDVEepOeOiWJyINAa2PMjZGui1JKnaq0L1bRSj9pKaWUUkopVYUGyEoppZRSSlWhUyyUUkoppZSqQkeQlVJKKaWUqkIDZKWUUkopparQAFkppZRSSqkqNEBWSimllFKqCg2QlVJKKaWUquL/AX/F1IPAP5G7AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 可视化观察训练集与验证集的指标变化情况\n",
    "def plot(runner,fig_name):\n",
    "    plt.figure(figsize=(10,5))\n",
    "    plt.subplot(1,2,1)\n",
    "    epochs = [i for i in range(len(runner.train_scores))]\n",
    "    # 绘制训练损失变化曲线\n",
    "    plt.plot(epochs, runner.train_loss, color='#e4007f', label=\"Train loss\")\n",
    "    # 绘制评价损失变化曲线\n",
    "    plt.plot(epochs, runner.dev_loss, color='#f19ec2', linestyle='--', label=\"Dev loss\")\n",
    "    # 绘制坐标轴和图例\n",
    "    plt.ylabel(\"loss\", fontsize='large')\n",
    "    plt.xlabel(\"epoch\", fontsize='large')\n",
    "    plt.legend(loc='upper right', fontsize='x-large')\n",
    "    plt.subplot(1,2,2)\n",
    "    # 绘制训练准确率变化曲线\n",
    "    plt.plot(epochs, runner.train_scores, color='#e4007f', label=\"Train accuracy\")\n",
    "    # 绘制评价准确率变化曲线\n",
    "    plt.plot(epochs, runner.dev_scores, color='#f19ec2', linestyle='--', label=\"Dev accuracy\")\n",
    "    # 绘制坐标轴和图例\n",
    "    plt.ylabel(\"score\", fontsize='large')\n",
    "    plt.xlabel(\"epoch\", fontsize='large')\n",
    "    plt.legend(loc='lower right', fontsize='x-large')\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(fig_name)\n",
    "    plt.show()\n",
    "\n",
    "plot(runner,fig_name='linear-acc.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从输出结果可以看到，在训练集与验证集上，loss得到了收敛，同时准确率指标都达到了较高的水平，训练比较充分。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.1.8 模型评价\n",
    "\n",
    "使用测试集对训练完成后的最终模型进行评价，观察模型在测试集上的准确率和loss数据。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test] score/loss: 0.8100/0.4356\n"
     ]
    }
   ],
   "source": [
    "score, loss = runner.evaluate([X_test, y_test])\n",
    "print(\"[Test] score/loss: {:.4f}/{:.4f}\".format(score, loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可视化观察拟合的决策边界 $\\boldsymbol{X} \\boldsymbol{w} + b=0$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def decision_boundary(w, b, x1):\n",
    "    w1, w2 = w\n",
    "    x2 = (- w1 * x1 - b) / w2\n",
    "    return x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,5))\n",
    "# 绘制原始数据\n",
    "plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())\n",
    "\n",
    "w = model.params['w']\n",
    "b = model.params['b']\n",
    "x1 = paddle.linspace(-2, 3, 1000)\n",
    "x2 = decision_boundary(w, b, x1)\n",
    "# 绘制决策边界\n",
    "plt.plot(x1.tolist(), x2.tolist(), color=\"red\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 3.2 基于Softmax回归的多分类任务\n",
    "\n",
    "Logistic回归可以有效地解决二分类问题，但在分类任务中，还有一类多分类问题，即类别数$C$大于2 的分类问题。Softmax回归就是Logistic回归在多分类问题上的推广。\n",
    "\n",
    "使用Softmax回归模型对一个简单的数据集进行多分类实验。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.1 数据集构建\n",
    "\n",
    "我们首先构建一个简单的多分类任务，并构建训练集、验证集和测试集。\n",
    "本任务的数据来自3个不同的簇，每个簇对一个类别。我们采集1000条样本，每个样本包含2个特征。\n",
    "\n",
    "数据集的构建函数`make_multi`的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "\n",
    "def make_multiclass_classification(n_samples=100, n_features=2, n_classes=3, shuffle=True, noise=0.1):\n",
    "    \"\"\"\n",
    "    生成带噪音的多类别数据\n",
    "    输入：\n",
    "        - n_samples：数据量大小，数据类型为int\n",
    "        - n_features：特征数量，数据类型为int\n",
    "        - shuffle：是否打乱数据，数据类型为bool\n",
    "        - noise：以多大的程度增加噪声，数据类型为None或float，noise为None时表示不增加噪声\n",
    "    输出：\n",
    "        - X：特征数据，shape=[n_samples,2]\n",
    "        - y：标签数据, shape=[n_samples,1]\n",
    "    \"\"\"\n",
    "    # 计算每个类别的样本数量\n",
    "    n_samples_per_class = [int(n_samples / n_classes) for k in range(n_classes)]\n",
    "    for i in range(n_samples - sum(n_samples_per_class)):\n",
    "        n_samples_per_class[i % n_classes] += 1\n",
    "    # 将特征和标签初始化为0\n",
    "    X = paddle.zeros([n_samples, n_features])\n",
    "    y = paddle.zeros([n_samples], dtype='int32')\n",
    "    # 随机生成3个簇中心作为类别中心\n",
    "    centroids = paddle.randperm(2 ** n_features)[:n_classes]\n",
    "    centroids_bin = np.unpackbits(centroids.numpy().astype('uint8')).reshape((-1, 8))[:, -n_features:]\n",
    "    centroids = paddle.to_tensor(centroids_bin, dtype='float32')\n",
    "    # 控制簇中心的分离程度\n",
    "    centroids = 1.5 * centroids - 1\n",
    "    # 随机生成特征值\n",
    "    X[:, :n_features] = paddle.randn(shape=[n_samples, n_features])\n",
    "\n",
    "    stop = 0\n",
    "    # 将每个类的特征值控制在簇中心附近\n",
    "    for k, centroid in enumerate(centroids):\n",
    "        start, stop = stop, stop + n_samples_per_class[k]\n",
    "        # 指定标签值\n",
    "        y[start:stop] = k % n_classes\n",
    "        X_k = X[start:stop, :n_features]\n",
    "        # 控制每个类别特征值的分散程度\n",
    "        A = 2 * paddle.rand(shape=[n_features, n_features]) - 1\n",
    "        X_k[...] = paddle.matmul(X_k, A)\n",
    "        X_k += centroid\n",
    "        X[start:stop, :n_features] = X_k\n",
    "\n",
    "    # 如果noise不为None，则给特征加入噪声\n",
    "    if noise > 0.0:\n",
    "        # 生成noise掩膜，用来指定给那些样本加入噪声\n",
    "        noise_mask = paddle.rand([n_samples]) < noise\n",
    "        for i in range(len(noise_mask)):\n",
    "            if noise_mask[i]:\n",
    "                # 给加噪声的样本随机赋标签值\n",
    "                y[i] = paddle.randint(n_classes, shape=[1]).astype('int32')\n",
    "    # 如果shuffle为True，将所有数据打乱\n",
    "    if shuffle:\n",
    "        idx = paddle.randperm(X.shape[0])\n",
    "        X = X[idx]\n",
    "        y = y[idx]\n",
    "\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "随机采集1000个样本，并进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'paddle' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_93/3766463464.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# 固定随机种子，保持每次运行结果一致\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpaddle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m102\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;31m# 采样1000个样本\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1000\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmake_multiclass_classification\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mn_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_features\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_classes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnoise\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'paddle' is not defined"
     ]
    }
   ],
   "source": [
    "# 固定随机种子，保持每次运行结果一致\n",
    "paddle.seed(102)\n",
    "# 采样1000个样本\n",
    "n_samples = 1000\n",
    "X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)\n",
    "\n",
    "# 可视化生产的数据集，不同颜色代表不同类别\n",
    "plt.figure(figsize=(5,5))\n",
    "plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist())\n",
    "plt.savefig('linear-dataset-vis2.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "将实验数据拆分成训练集、验证集和测试集。其中训练集640条、验证集160条、测试集200条。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape:  [640, 2] y_train shape:  [640]\n"
     ]
    }
   ],
   "source": [
    "num_train = 640\n",
    "num_dev = 160\n",
    "num_test = 200\n",
    "\n",
    "X_train, y_train = X[:num_train], y[:num_train]\n",
    "X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]\n",
    "X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]\n",
    "\n",
    "# 打印X_train和y_train的维度\n",
    "print(\"X_train shape: \", X_train.shape, \"y_train shape: \", y_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "这样，我们就完成了Multi1000数据集的构建。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[5], dtype=int32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [2, 0, 1, 0, 2])\n"
     ]
    }
   ],
   "source": [
    "# 打印前5个数据的标签\n",
    "print(y_train[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.2 模型构建\n",
    "\n",
    "在Softmax回归中，对类别进行预测的方式是预测输入属于每个类别的条件概率。与Logistic 回归不同的是，Softmax回归的输出值个数等于类别数$C$，而每个类别的概率值则通过Softmax函数进行求解。\n",
    "\n",
    "#### 3.2.2.1 Softmax函数\n",
    "\n",
    "Softmax函数可以将多个标量映射为一个概率分布。对于一个$K$维向量，$\\mathbf x=[x_1,\\cdots,x_K]$，Softmax的计算公式为\n",
    "\n",
    "$$\n",
    "\\mathrm{softmax}(x_k) = \\frac{\\exp(x_k)}{\\sum_{i=1}^K \\exp(x_i)}。（3.11）\n",
    "$$\n",
    "\n",
    "在Softmax函数的计算过程中，要注意**上溢出**和**下溢出**的问题。假设Softmax 函数中所有的$x_k$都是相同大小的数值$a$，理论上，所有的输出都应该为$\\frac{1}{k}$。但需要考虑如下两种特殊情况：\n",
    "\n",
    "* $a$为一个非常大的负数，此时$\\exp(a)$ 会发生下溢出现象。计算机在进行数值计算时，当数值过小，会被四舍五入为0。此时，Softmax函数的分母会变为0，导致计算出现问题；\n",
    "* $a$为一个非常大的正数，此时会导致$\\exp(a)$发生上溢出现象，导致计算出现问题。\n",
    "\n",
    "为了解决上溢出和下溢出的问题，在计算Softmax函数时，可以使用$x_k - \\max(\\mathbf x)$代替$x_k$。 此时，通过减去最大值，$x_k$最大为0，避免了上溢出的问题；同时，分母中至少会包含一个值为1的项，从而也避免了下溢出的问题。\n",
    "\n",
    "Softmax函数的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[2, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[0.21383820, 0.23632778, 0.26118261, 0.28865141],\n",
      "        [0.03205860, 0.08714432, 0.23688284, 0.64391422]])\n"
     ]
    }
   ],
   "source": [
    "# x为tensor\n",
    "def softmax(X):\n",
    "    \"\"\"\n",
    "    输入：\n",
    "        - X：shape=[N, C]，N为向量数量，C为向量维度\n",
    "    \"\"\"\n",
    "    x_max = paddle.max(X, axis=1, keepdim=True)#N,1\n",
    "    x_exp = paddle.exp(X - x_max)\n",
    "    partition = paddle.sum(x_exp, axis=1, keepdim=True)#N,1\n",
    "    return x_exp / partition\n",
    "\n",
    "# 观察softmax的计算方式\n",
    "X = paddle.to_tensor([[0.1, 0.2, 0.3, 0.4],[1,2,3,4]])\n",
    "predict = softmax(X)\n",
    "print(predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 3.2.2.2 Softmax回归算子\n",
    "\n",
    "在Softmax回归中，类别标签$y\\in\\{1,2,…,C\\}$。给定一个样本$\\mathbf x$，使用Softmax回归预测的属于类别$c$的条件概率为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "p(y=c|\\mathbf x) &= \\mathrm{softmax}(\\mathbf w_c^T \\mathbf x+b_c)，（3.12）\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "其中$\\mathbf w_c$是第 $c$ 类的权重向量，$b_c$是第 $c$ 类的偏置。\n",
    "\n",
    "Softmax回归模型其实就是线性函数与Softmax函数的组合。\n",
    "\n",
    "将$N$个样本归为一组进行成批地预测。\n",
    "\n",
    "$$\n",
    "\\hat{\\mathbf Y} = \\mathrm{softmax}(\\boldsymbol{X} \\boldsymbol{W} + \\mathbf b), (3.13)\n",
    "$$\n",
    "\n",
    "其中$\\boldsymbol{X}\\in \\mathbb{R}^{N\\times D}$为$N$个样本的特征矩阵，$\\boldsymbol{W}=[\\mathbf w_1,……,\\mathbf w_C]$为$C$个类的权重向量组成的矩阵，$\\hat{\\mathbf Y}\\in \\mathbb{R}^{C}$为所有类别的预测条件概率组成的矩阵。\n",
    "\n",
    "我们根据公式（3.13）实现Softmax回归算子，代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input is: Tensor(shape=[1, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[-0.51168263, -0.10752964,  0.67060655,  0.26857111]])\n",
      "Output is: Tensor(shape=[1, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[0.33333334, 0.33333334, 0.33333334]])\n"
     ]
    }
   ],
   "source": [
    "class model_SR(op.Op):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(model_SR, self).__init__()\n",
    "        self.params = {}\n",
    "        # 将线性层的权重参数全部初始化为0\n",
    "        self.params['W'] = paddle.zeros(shape=[input_dim, output_dim])\n",
    "        # self.params['W'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, output_dim])\n",
    "        # 将线性层的偏置参数初始化为0\n",
    "        self.params['b'] = paddle.zeros(shape=[output_dim])\n",
    "        self.outputs = None\n",
    "\n",
    "    def __call__(self, inputs):\n",
    "        return self.forward(inputs)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - inputs: shape=[N,D], N是样本数量，D是特征维度\n",
    "        输出：\n",
    "            - outputs：预测值，shape=[N,C]，C是类别数\n",
    "        \"\"\"\n",
    "        # 线性计算\n",
    "        score = paddle.matmul(inputs, self.params['W']) + self.params['b']\n",
    "        # Softmax 函数\n",
    "        self.outputs = softmax(score)\n",
    "        return self.outputs\n",
    "\n",
    "# 随机生成1条长度为4的数据\n",
    "inputs = paddle.randn(shape=[1,4])\n",
    "print('Input is:', inputs)\n",
    "# 实例化模型，这里令输入长度为4，输出类别数为3\n",
    "model = model_SR(input_dim=4, output_dim=3)\n",
    "outputs = model(inputs)\n",
    "print('Output is:', outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从输出结果可以看出，采用全0初始化后，属于每个类别的条件概率均为$\\frac{1}{C}$。这是因为，不论输入值的大小为多少，线性函数$f(\\mathbf x;\\mathbf W,\\mathbf b)$的输出值恒为0。此时，再经过Softmax函数的处理，每个类别的条件概率恒等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.3 损失函数\n",
    "\n",
    "Softmax回归同样使用交叉熵损失作为损失函数，并使用梯度下降法对参数进行优化。通常使用$C$维的one-hot类型向量$\\mathbf y \\in \\{0,1\\}^C$来表示多分类任务中的类别标签。对于类别$c$，其向量表示为：\n",
    "\n",
    "$$\n",
    "\\mathbf y = [I(1=c),I(2=c),…,I(C=c)]^T，（3.14）\n",
    "$$\n",
    "\n",
    "其中$I(·)$是指示函数，即括号内的输入为“真”，$I(·)=1$；否则，$I(·)=0$。\n",
    "\n",
    "给定有$N$个训练样本的训练集$\\{(\\mathbf x^{(n)},y^{(n)})\\} ^N_{n=1}$，令$\\hat{\\mathbf y}^{(n)}=\\mathrm{softmax}(\\mathbf W^ \\mathrm{ T } \\mathbf x^{(n)}+\\mathbf b)$为样本$\\mathbf x^{(n)}$在每个类别的后验概率。多分类问题的交叉熵损失函数定义为：\n",
    "\n",
    "$$\n",
    "\\cal R(\\mathbf W,\\mathbf b) = -\\frac{1}{N}\\sum_{n=1}^N (\\mathbf y^{(n)})^ \\mathrm{ T } \\log\\hat{\\mathbf y}^{(n)} = -\\frac{1}{N}\\sum_{n=1}^N \\sum_{c=1}^C \\mathbf y_c^{(n)} \\log\\hat{\\mathbf y}_c^{(n)}.（3.15）\n",
    "$$\n",
    "\n",
    "观察上式，$\\mathbf y_c^{(n)}$在$c$为真实类别时为1，其余都为0。也就是说，交叉熵损失只关心正确类别的预测概率，因此，上式又可以优化为：\n",
    "\n",
    "$$\n",
    "\\cal R(\\mathbf W,\\mathbf b) = -\\frac{1}{N}\\sum_{n=1}^N \\log [\\hat{\\mathbf y}^{(n)}]_{y^{(n)}},（3.16）\n",
    "$$\n",
    "\n",
    "其中$y^{(n)}$是第$n$个样本的标签。\n",
    "\n",
    "因此，多类交叉熵损失函数的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [1.09861231])\n"
     ]
    }
   ],
   "source": [
    "class MultiCrossEntropyLoss(op.Op):\n",
    "    def __init__(self):\n",
    "        self.predicts = None\n",
    "        self.labels = None\n",
    "        self.num = None\n",
    "\n",
    "    def __call__(self, predicts, labels):\n",
    "        return self.forward(predicts, labels)\n",
    "\n",
    "    def forward(self, predicts, labels):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - predicts：预测值，shape=[N, 1]，N为样本数量\n",
    "            - labels：真实标签，shape=[N, 1]\n",
    "        输出：\n",
    "            - 损失值：shape=[1]\n",
    "        \"\"\"\n",
    "        self.predicts = predicts\n",
    "        self.labels = labels\n",
    "        self.num = self.predicts.shape[0]\n",
    "        loss = 0\n",
    "        for i in range(0, self.num):\n",
    "            index = self.labels[i]\n",
    "            loss -= paddle.log(self.predicts[i][index])\n",
    "        return loss / self.num\n",
    "\n",
    "# 测试一下\n",
    "# 假设真实标签为第1类\n",
    "labels = paddle.to_tensor([0])\n",
    "# 计算风险函数\n",
    "mce_loss = MultiCrossEntropyLoss()\n",
    "print(mce_loss(outputs, labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.4 模型优化\n",
    "\n",
    "使用梯度下降法进行参数学习。\n",
    "\n",
    "#### 3.2.4.1 梯度计算\n",
    "\n",
    "计算风险函数$\\cal R(\\mathbf W,\\mathbf b)$关于参数$\\mathbf W$和$\\mathbf b$的偏导数。在Softmax回归中，计算方法为：\n",
    "\n",
    "$$\n",
    "\\frac{\\partial \\cal R(\\mathbf W,\\mathbf b)}{\\partial \\mathbf W} = -\\frac{1}{N}\\sum_{n=1}^N \\mathbf x^{(n)}(y^{(n)}- \\hat{ y}^{(n)})^T = -\\frac{1}{N} \\mathbf X^ \\mathrm{ T } (\\mathbf y- \\hat{\\mathbf y}),（3.17）\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\frac{\\partial \\cal R(\\mathbf W,\\mathbf b)}{\\partial \\mathbf b} = -\\frac{1}{N}\\sum_{n=1}^N (y^{(n)}- \\hat{y}^{(n)})^T = -\\frac{1}{N} \\mathbf 1 (\\mathbf y- \\hat{\\mathbf y}).（3.18）\n",
    "$$\n",
    "\n",
    "其中$\\mathbf X\\in \\mathbb{R}^{N\\times D}$为$N$个样本组成的矩阵，$\\mathbf y\\in \\mathbb{R}^{N}$为$N$个样本标签组成的向量，$\\hat{\\mathbf y}\\in \\mathbb{R}^{N}$为$N$个样本的预测标签组成的向量，$\\mathbf{1}$为$N$维的全1向量。\n",
    "\n",
    "将上述计算方法定义在模型的`backward`函数中，代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class model_SR(op.Op):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(model_SR, self).__init__()\n",
    "        self.params = {}\n",
    "        # 将线性层的权重参数全部初始化为0\n",
    "        self.params['W'] = paddle.zeros(shape=[input_dim, output_dim])\n",
    "        # self.params['W'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, output_dim])\n",
    "        # 将线性层的偏置参数初始化为0\n",
    "        self.params['b'] = paddle.zeros(shape=[output_dim])\n",
    "        # 存放参数的梯度\n",
    "        self.grads = {}\n",
    "        self.X = None\n",
    "        self.outputs = None\n",
    "        self.output_dim = output_dim\n",
    "\n",
    "    def __call__(self, inputs):\n",
    "        return self.forward(inputs)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        self.X = inputs\n",
    "        # 线性计算\n",
    "        score = paddle.matmul(self.X, self.params['W']) + self.params['b']\n",
    "        # Softmax 函数\n",
    "        self.outputs = softmax(score)\n",
    "        return self.outputs\n",
    "\n",
    "    def backward(self, labels):\n",
    "        \"\"\"\n",
    "        输入：\n",
    "            - labels：真实标签，shape=[N, 1]，其中N为样本数量\n",
    "        \"\"\"\n",
    "        # 计算偏导数\n",
    "        N =labels.shape[0]\n",
    "        labels = paddle.nn.functional.one_hot(labels, self.output_dim)\n",
    "        self.grads['W'] = -1 / N * paddle.matmul(self.X.t(), (labels-self.outputs))\n",
    "        self.grads['b'] = -1 / N * paddle.matmul(paddle.ones(shape=[N]), (labels-self.outputs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 3.2.4.2 参数更新\n",
    "\n",
    "在计算参数的梯度之后，我们使用3.1.4.2中实现的梯度下降法进行参数更新。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.5 模型训练\n",
    "\n",
    "实例化RunnerV2类，并传入训练配置。使用训练集和验证集进行模型训练，共训练500个epoch。每隔50个epoch打印训练集上的指标。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best accuracy performence has been updated: 0.00000 --> 0.71250\n",
      "[Train] epoch: 0, loss: 1.098615050315857, score: 0.3453125059604645\n",
      "[Dev] epoch: 0, loss: 1.0776067972183228, score: 0.7124999761581421\n",
      "best accuracy performence has been updated: 0.71250 --> 0.71875\n",
      "best accuracy performence has been updated: 0.71875 --> 0.72500\n",
      "best accuracy performence has been updated: 0.72500 --> 0.73125\n",
      "best accuracy performence has been updated: 0.73125 --> 0.73750\n",
      "best accuracy performence has been updated: 0.73750 --> 0.74375\n",
      "best accuracy performence has been updated: 0.74375 --> 0.75625\n",
      "best accuracy performence has been updated: 0.75625 --> 0.76250\n",
      "best accuracy performence has been updated: 0.76250 --> 0.76875\n",
      "[Train] epoch: 100, loss: 0.6804651618003845, score: 0.8015625476837158\n",
      "[Dev] epoch: 100, loss: 0.7366783618927002, score: 0.768750011920929\n",
      "[Train] epoch: 200, loss: 0.6404480338096619, score: 0.8140625357627869\n",
      "[Dev] epoch: 200, loss: 0.7034932971000671, score: 0.7625000476837158\n",
      "best accuracy performence has been updated: 0.76875 --> 0.76875\n",
      "[Train] epoch: 300, loss: 0.6286336779594421, score: 0.817187488079071\n",
      "[Dev] epoch: 300, loss: 0.6940505504608154, score: 0.7625000476837158\n",
      "[Train] epoch: 400, loss: 0.6242581009864807, score: 0.815625011920929\n",
      "[Dev] epoch: 400, loss: 0.6909448504447937, score: 0.7625000476837158\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 固定随机种子，保持每次运行结果一致\n",
    "paddle.seed(102)\n",
    "\n",
    "# 特征维度\n",
    "input_dim = 2\n",
    "# 类别数\n",
    "output_dim = 3\n",
    "# 学习率\n",
    "lr = 0.1\n",
    "\n",
    "# 实例化模型\n",
    "model = model_SR(input_dim=input_dim, output_dim=output_dim)\n",
    "# 指定优化器\n",
    "optimizer = SimpleBatchGD(init_lr=lr, model=model)\n",
    "# 指定损失函数\n",
    "loss_fn = MultiCrossEntropyLoss()\n",
    "# 指定评价方式\n",
    "metric = accuracy\n",
    "# 实例化RunnerV2类\n",
    "runner = RunnerV2(model, optimizer, metric, loss_fn)\n",
    "\n",
    "# 模型训练\n",
    "runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_eopchs=50, eval_epochs=1, save_path=\"best_model.pdparams\")\n",
    "\n",
    "# 可视化观察训练集与验证集的准确率变化情况\n",
    "plot(runner,fig_name='linear-acc2.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 3.2.6 模型评价\n",
    "\n",
    "使用测试集对训练完成后的最终模型进行评价，观察模型在测试集上的准确率。代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test] score/loss: 0.7750/0.6583\n"
     ]
    }
   ],
   "source": [
    "score, loss = runner.evaluate([X_test, y_test])\n",
    "print(\"[Test] score/loss: {:.4f}/{:.4f}\".format(score, loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可视化观察类别划分结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fe18c6ba910>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 均匀生成40000个数据点\n",
    "x1, x2 = paddle.meshgrid(paddle.linspace(-3.5, 2, 200), paddle.linspace(-4.5, 3.5, 200))\n",
    "x = paddle.stack([paddle.flatten(x1), paddle.flatten(x2)], axis=1)\n",
    "# 预测对应类别\n",
    "y = runner.predict(x)\n",
    "y = paddle.argmax(y, axis=1)\n",
    "# 绘制类别区域\n",
    "plt.ylabel('x2')\n",
    "plt.xlabel('x1')\n",
    "plt.scatter(x[:,0].tolist(), x[:,1].tolist(), c=y.tolist(), cmap=plt.cm.Spectral)\n",
    "\n",
    "paddle.seed(102)\n",
    "n_samples = 1000\n",
    "X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)\n",
    "\n",
    "plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**********\n",
    "\n",
    "**拓展**\n",
    "\n",
    "提前停止是在使用梯度下降法进行模型优化时常用的正则化方法。对于某些拟合能力非常强的机器学习算法，当训练轮数较多时，容易发生过拟合现象，即在训练集上错误率很低，但是在未知数据（或测试集）上错误率很高。为了解决这一问题，通常会在模型优化时，使用验证集上的错误代替期望错误。当验证集上的错误率不在下降时，就停止迭代。\n",
    "\n",
    "在3.4.3节的实验中，模型训练过程中会按照提前停止的思想保存验证集上的最优模型。\n",
    "\n",
    "**********"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
